[5017] Distribute new example files

diff --cc doc/Makefile.am
index 5aa8fe72ed8119f2625fd626863b0c5cb10d69fa,5aa8fe72ed8119f2625fd626863b0c5cb10d69fa..9bb83c60ea8750070f7240183958afec38343f67
--- 1/doc/Makefile.am
--- 2/doc/Makefile.am
+++ b/doc/Makefile.am
@@@ -10,6 -10,6 +10,7 @@@ nobase_dist_doc_DATA  = examples/ddns/s
  nobase_dist_doc_DATA += examples/ddns/template.json
  nobase_dist_doc_DATA += examples/kea4/backends.json
  nobase_dist_doc_DATA += examples/kea4/classify.json
++nobase_dist_doc_DATA += examples/kea4/dhcpv4-over-dhcpv6.json
  nobase_dist_doc_DATA += examples/kea4/hooks.json
  nobase_dist_doc_DATA += examples/kea4/leases-expiration.json
  nobase_dist_doc_DATA += examples/kea4/multiple-options.json
@@@ -21,6 -21,6 +22,8 @@@ nobase_dist_doc_DATA += examples/kea4/s
  nobase_dist_doc_DATA += examples/kea6/advanced.json
  nobase_dist_doc_DATA += examples/kea6/backends.json
  nobase_dist_doc_DATA += examples/kea6/classify.json
++nobase_dist_doc_DATA += examples/kea6/dhcpv4-over-dhcpv6.json
++nobase_dist_doc_DATA += examples/kea6/duid.json
  nobase_dist_doc_DATA += examples/kea6/hooks.json
  nobase_dist_doc_DATA += examples/kea6/leases-expiration.json
  nobase_dist_doc_DATA += examples/kea6/multiple-options.json

diff --cc src/bin/dhcp4/dhcp4_lexer.ll
index 1f3342590531fe5aa8e9855cb515ba1c33fd2951,0000000000000000000000000000000000000000..7f009734638928fd6aa1f8d16daa153b17000dad
mode 100644,000000..100644
--- 1/src/bin/dhcp4/dhcp4_lexer.ll
--- /dev/null
+++ b/src/bin/dhcp4/dhcp4_lexer.ll
@@@ -1,1169 -1,0 +1,1210 @@@
-                 // not yet implemented
-                 driver.error(driver.loc_, "Unsupported unicode escape in \"" + raw + "\"");
 +/* Copyright (C) 2016 Internet Systems Consortium, Inc. ("ISC")
 +
 +   This Source Code Form is subject to the terms of the Mozilla Public
 +   License, v. 2.0. If a copy of the MPL was not distributed with this
 +   file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 +
 +%{ /* -*- C++ -*- */
 +#include <cerrno>
 +#include <climits>
 +#include <cstdlib>
 +#include <string>
 +#include <dhcp4/parser_context.h>
 +#include <asiolink/io_address.h>
 +#include <boost/lexical_cast.hpp>
 +#include <exceptions/exceptions.h>
 +
 +// Work around an incompatibility in flex (at least versions
 +// 2.5.31 through 2.5.33): it generates code that does
 +// not conform to C89.  See Debian bug 333231
 +// <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>.
 +# undef yywrap
 +# define yywrap() 1
 +
 +namespace {
 +
 +bool start_token_flag = false;
 +
 +isc::dhcp::Parser4Context::ParserType start_token_value;
 +unsigned int comment_start_line = 0;
 +
 +};
 +
 +// To avoid the call to exit... oops!
 +#define YY_FATAL_ERROR(msg) isc::dhcp::Parser4Context::fatal(msg)
 +%}
 +
 +/* noyywrap disables automatic rewinding for the next file to parse. Since we
 +   always parse only a single string, there's no need to do any wraps. And
 +   using yywrap requires linking with -lfl, which provides the default yywrap
 +   implementation that always returns 1 anyway. */
 +%option noyywrap
 +
 +/* nounput simplifies the lexer, by removing support for putting a character
 +   back into the input stream. We never use such capability anyway. */
 +%option nounput
 +
 +/* batch means that we'll never use the generated lexer interactively. */
 +%option batch
 +
 +/* avoid to get static global variables to remain with C++. */
 +/* in last resort %option reentrant */
 +
 +/* Enables debug mode. To see the debug messages, one needs to also set
 +   yy_flex_debug to 1, then the debug messages will be printed on stderr. */
 +%option debug
 +
 +/* I have no idea what this option does, except it was specified in the bison
 +   examples and Postgres folks added it to remove gcc 4.3 warnings. Let's
 +   be on the safe side and keep it. */
 +%option noinput
 +
 +%x COMMENT
 +%x DIR_ENTER DIR_INCLUDE DIR_EXIT
 +
 +/* These are not token expressions yet, just convenience expressions that
 +   can be used during actual token definitions. Note some can match
 +   incorrect inputs (e.g., IP addresses) which must be checked. */
 +int   \-?[0-9]+
 +blank [ \t\r]
 +
 +UnicodeEscapeSequence           u[0-9A-Fa-f]{4}
 +JSONEscapeCharacter             ["\\/bfnrt]
 +JSONEscapeSequence              {JSONEscapeCharacter}|{UnicodeEscapeSequence}
 +JSONStandardCharacter           [^\x00-\x1f"\\]
 +JSONStringCharacter             {JSONStandardCharacter}|\\{JSONEscapeSequence}
 +JSONString                      \"{JSONStringCharacter}*\"
 +
 +/* for errors */
 +
 +BadUnicodeEscapeSequence        u[0-9A-Fa-f]{0,3}[^0-9A-Fa-f]
 +BadJSONEscapeSequence           [^"\\/bfnrtu]|{BadUnicodeEscapeSequence}
 +ControlCharacter                [\x00-\x1f]
 +ControlCharacterFill            [^"\\]|\\{JSONEscapeSequence}
 +
 +%{
 +// This code run each time a pattern is matched. It updates the location
 +// by moving it ahead by yyleng bytes. yyleng specifies the length of the
 +// currently matched token.
 +#define YY_USER_ACTION  driver.loc_.columns(yyleng);
 +%}
 +
 +%%
 +
 +%{
 +    // This part of the code is copied over to the verbatim to the top
 +    // of the generated yylex function. Explanation:
 +    // http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html
 +
 +    // Code run each time yylex is called.
 +    driver.loc_.step();
 +
 +    if (start_token_flag) {
 +        start_token_flag = false;
 +        switch (start_token_value) {
 +        case Parser4Context::PARSER_JSON:
 +        default:
 +            return isc::dhcp::Dhcp4Parser::make_TOPLEVEL_JSON(driver.loc_);
 +        case Parser4Context::PARSER_DHCP4:
 +            return isc::dhcp::Dhcp4Parser::make_TOPLEVEL_DHCP4(driver.loc_);
 +        case Parser4Context::SUBPARSER_DHCP4:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_DHCP4(driver.loc_);
 +        case Parser4Context::PARSER_INTERFACES:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_INTERFACES4(driver.loc_);
 +        case Parser4Context::PARSER_SUBNET4:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_SUBNET4(driver.loc_);
 +        case Parser4Context::PARSER_POOL4:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_POOL4(driver.loc_);
 +        case Parser4Context::PARSER_HOST_RESERVATION:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_RESERVATION(driver.loc_);
 +        case Parser4Context::PARSER_OPTION_DATA:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_OPTION_DATA(driver.loc_);
 +        case Parser4Context::PARSER_HOOKS_LIBRARY:
 +            return isc::dhcp::Dhcp4Parser::make_SUB_HOOKS_LIBRARY(driver.loc_);
 +        }
 +    }
 +%}
 +
 +#.* ;
 +
 +"//"(.*) ;
 +
 +"/*" {
 +  BEGIN(COMMENT);
 +  comment_start_line = driver.loc_.end.line;;
 +}
 +
 +<COMMENT>"*/" BEGIN(INITIAL);
 +<COMMENT>. ;
 +<COMMENT><<EOF>> {
 +    isc_throw(Dhcp4ParseError, "Comment not closed. (/* in line " << comment_start_line);
 +}
 +
 +"<?" BEGIN(DIR_ENTER);
 +<DIR_ENTER>"include" BEGIN(DIR_INCLUDE);
 +<DIR_INCLUDE>\"([^\"\n])+\" {
 +    // Include directive.
 +
 +    // Extract the filename.
 +    std::string tmp(yytext+1);
 +    tmp.resize(tmp.size() - 1);
 +
 +    driver.includeFile(tmp);
 +}
 +<DIR_ENTER,DIR_INCLUDE,DIR_EXIT><<EOF>> {
 +    isc_throw(Dhcp4ParseError, "Directive not closed.");
 +}
 +<DIR_EXIT>"?>" BEGIN(INITIAL);
 +
 +
 +<*>{blank}+   {
 +    // Ok, we found a with space. Let's ignore it and update loc variable.
 +    driver.loc_.step();
 +}
 +
 +<*>[\n]+      {
 +    // Newline found. Let's update the location and continue.
 +    driver.loc_.lines(yyleng);
 +    driver.loc_.step();
 +}
 +
 +
 +\"Dhcp4\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CONFIG:
 +        return isc::dhcp::Dhcp4Parser::make_DHCP4(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("Dhcp4", driver.loc_);
 +    }
 +}
 +
 +\"interfaces-config\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return  isc::dhcp::Dhcp4Parser::make_INTERFACES_CONFIG(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("interfaces-config", driver.loc_);
 +    }
 +}
 +
 +\"interfaces\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::INTERFACES_CONFIG:
 +        return  isc::dhcp::Dhcp4Parser::make_INTERFACES(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("interfaces", driver.loc_);
 +    }
 +}
 +
 +\"lease-database\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_LEASE_DATABASE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("lease-database", driver.loc_);
 +    }
 +}
 +
 +\"hosts-database\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_HOSTS_DATABASE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("hosts-database", driver.loc_);
 +    }
 +}
 +
 +\"readonly\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +        return isc::dhcp::Dhcp4Parser::make_READONLY(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("readonly", driver.loc_);
 +    }
 +}
 +
 +\"type\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +    case isc::dhcp::Parser4Context::SERVER_ID:
 +        return isc::dhcp::Dhcp4Parser::make_TYPE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("type", driver.loc_);
 +    }
 +}
 +
 +\"user\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +        return isc::dhcp::Dhcp4Parser::make_USER(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("user", driver.loc_);
 +    }
 +}
 +
 +\"password\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +        return isc::dhcp::Dhcp4Parser::make_PASSWORD(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("password", driver.loc_);
 +    }
 +}
 +
 +\"host\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +        return isc::dhcp::Dhcp4Parser::make_HOST(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("host", driver.loc_);
 +    }
 +}
 +
 +\"persist\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +    case isc::dhcp::Parser4Context::SERVER_ID:
 +        return isc::dhcp::Dhcp4Parser::make_PERSIST(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("persist", driver.loc_);
 +    }
 +}
 +
 +\"lfc-interval\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +        return isc::dhcp::Dhcp4Parser::make_LFC_INTERVAL(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("lfc-interval", driver.loc_);
 +    }
 +}
 +
 +\"valid-lifetime\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_VALID_LIFETIME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("valid-lifetime", driver.loc_);
 +    }
 +}
 +
 +\"renew-timer\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_RENEW_TIMER(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("renew-timer", driver.loc_);
 +    }
 +}
 +
 +\"rebind-timer\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_REBIND_TIMER(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("rebind-timer", driver.loc_);
 +    }
 +}
 +
 +\"decline-probation-period\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_DECLINE_PROBATION_PERIOD(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("decline-probation-period", driver.loc_);
 +    }
 +}
 +
 +\"subnet4\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_SUBNET4(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("subnet4", driver.loc_);
 +    }
 +}
 +
 +\"option-def\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_OPTION_DEF(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("option-def", driver.loc_);
 +    }
 +}
 +
 +\"option-data\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +    case isc::dhcp::Parser4Context::POOLS:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASS:
 +        return isc::dhcp::Dhcp4Parser::make_OPTION_DATA(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("option-data", driver.loc_);
 +    }
 +}
 +
 +\"name\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LEASE_DATABASE:
 +    case isc::dhcp::Parser4Context::HOSTS_DATABASE:
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +    case isc::dhcp::Parser4Context::OPTION_DATA:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASS:
 +    case isc::dhcp::Parser4Context::LOGGERS:
 +        return isc::dhcp::Dhcp4Parser::make_NAME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("name", driver.loc_);
 +    }
 +}
 +
 +\"data\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DATA:
 +        return isc::dhcp::Dhcp4Parser::make_DATA(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("data", driver.loc_);
 +    }
 +}
 +
 +\"pools\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_POOLS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("pools", driver.loc_);
 +    }
 +}
 +
 +\"pool\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::POOLS:
 +        return isc::dhcp::Dhcp4Parser::make_POOL(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("pool", driver.loc_);
 +    }
 +}
 +
 +\"subnet\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_SUBNET(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("subnet", driver.loc_);
 +    }
 +}
 +
 +\"interface\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_INTERFACE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("interface", driver.loc_);
 +    }
 +}
 +
 +\"interface-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_INTERFACE_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("interface-id", driver.loc_);
 +    }
 +}
 +
 +\"id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("id", driver.loc_);
 +    }
 +}
 +
 +\"rapid-commit\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_RAPID_COMMIT(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("rapid-commit", driver.loc_);
 +    }
 +}
 +
 +\"reservation-mode\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_RESERVATION_MODE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("reservation-mode", driver.loc_);
 +    }
 +}
 +
 +\"code\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +    case isc::dhcp::Parser4Context::OPTION_DATA:
 +        return isc::dhcp::Dhcp4Parser::make_CODE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("code", driver.loc_);
 +    }
 +}
 +
 +\"host-reservation-identifiers\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_HOST_RESERVATION_IDENTIFIERS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("host-reservation-identifiers", driver.loc_);
 +    }
 +}
 +
 +\"Logging\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CONFIG:
 +        return isc::dhcp::Dhcp4Parser::make_LOGGING(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("Logging", driver.loc_);
 +    }
 +}
 +
 +\"loggers\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LOGGING:
 +        return isc::dhcp::Dhcp4Parser::make_LOGGERS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("loggers", driver.loc_);
 +    }
 +}
 +
 +\"output_options\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LOGGERS:
 +        return isc::dhcp::Dhcp4Parser::make_OUTPUT_OPTIONS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("output_options", driver.loc_);
 +    }
 +}
 +
 +\"output\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OUTPUT_OPTIONS:
 +        return isc::dhcp::Dhcp4Parser::make_OUTPUT(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("output", driver.loc_);
 +    }
 +}
 +
 +\"debuglevel\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LOGGERS:
 +        return isc::dhcp::Dhcp4Parser::make_DEBUGLEVEL(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("debuglevel", driver.loc_);
 +    }
 +}
 +
 +\"severity\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::LOGGERS:
 +        return isc::dhcp::Dhcp4Parser::make_SEVERITY(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("severity", driver.loc_);
 +    }
 +}
 +
 +\"client-classes\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +        return isc::dhcp::Dhcp4Parser::make_CLIENT_CLASSES(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("client-classes", driver.loc_);
 +    }
 +}
 +
 +\"client-class\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +        return isc::dhcp::Dhcp4Parser::make_CLIENT_CLASS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("client-class", driver.loc_);
 +    }
 +}
 +
 +\"test\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASS:
 +        return isc::dhcp::Dhcp4Parser::make_TEST(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("test", driver.loc_);
 +    }
 +}
 +
 +\"reservations\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_RESERVATIONS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("reservations", driver.loc_);
 +    }
 +}
 +
 +\"duid\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOST_RESERVATION_IDENTIFIERS:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +        return isc::dhcp::Dhcp4Parser::make_DUID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("duid", driver.loc_);
 +    }
 +}
 +
 +\"hw-address\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOST_RESERVATION_IDENTIFIERS:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +        return isc::dhcp::Dhcp4Parser::make_HW_ADDRESS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("hw-address", driver.loc_);
 +    }
 +}
 +
 +\"client-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOST_RESERVATION_IDENTIFIERS:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +        return isc::dhcp::Dhcp4Parser::make_CLIENT_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("client-id", driver.loc_);
 +    }
 +}
 +
 +\"circuit-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOST_RESERVATION_IDENTIFIERS:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +        return isc::dhcp::Dhcp4Parser::make_CIRCUIT_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("circuit-id", driver.loc_);
 +    }
 +}
 +
 +\"hostname\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +        return isc::dhcp::Dhcp4Parser::make_HOSTNAME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("hostname", driver.loc_);
 +    }
 +}
 +
 +\"space\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +    case isc::dhcp::Parser4Context::OPTION_DATA:
 +        return isc::dhcp::Dhcp4Parser::make_SPACE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("space", driver.loc_);
 +    }
 +}
 +
 +\"csv-format\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DATA:
 +        return isc::dhcp::Dhcp4Parser::make_CSV_FORMAT(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("csv-format", driver.loc_);
 +    }
 +}
 +
 +\"record-types\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +        return isc::dhcp::Dhcp4Parser::make_RECORD_TYPES(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("record-types", driver.loc_);
 +    }
 +}
 +
 +\"encapsulate\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +        return isc::dhcp::Dhcp4Parser::make_ENCAPSULATE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("encapsulate", driver.loc_);
 +    }
 +}
 +
 +\"array\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::OPTION_DEF:
 +        return isc::dhcp::Dhcp4Parser::make_ARRAY(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("array", driver.loc_);
 +    }
 +}
 +
 +\"relay\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_RELAY(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("relay", driver.loc_);
 +    }
 +}
 +
 +\"ip-address\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::RELAY:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +    return isc::dhcp::Dhcp4Parser::make_IP_ADDRESS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("ip-address", driver.loc_);
 +    }
 +}
 +
 +\"hooks-libraries\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_HOOKS_LIBRARIES(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("hooks-libraries", driver.loc_);
 +    }
 +}
 +
 +
 +\"parameters\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOOKS_LIBRARIES:
 +        return isc::dhcp::Dhcp4Parser::make_PARAMETERS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("parameters", driver.loc_);
 +    }
 +}
 +
 +\"library\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::HOOKS_LIBRARIES:
 +        return isc::dhcp::Dhcp4Parser::make_LIBRARY(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("library", driver.loc_);
 +    }
 +}
 +
 +\"server-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_SERVER_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("server-id", driver.loc_);
 +    }
 +}
 +
 +\"identifier\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SERVER_ID:
 +        return isc::dhcp::Dhcp4Parser::make_IDENTIFIER(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("identifier", driver.loc_);
 +    }
 +}
 +
 +\"htype\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SERVER_ID:
 +        return isc::dhcp::Dhcp4Parser::make_HTYPE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("htype", driver.loc_);
 +    }
 +}
 +
 +\"time\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SERVER_ID:
 +        return isc::dhcp::Dhcp4Parser::make_TIME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("time", driver.loc_);
 +    }
 +}
 +
 +\"enterprise-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SERVER_ID:
 +        return isc::dhcp::Dhcp4Parser::make_ENTERPRISE_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("enterprise-id", driver.loc_);
 +    }
 +}
 +
 +\"expired-leases-processing\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_EXPIRED_LEASES_PROCESSING(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("expired-leases-processing", driver.loc_);
 +    }
 +}
 +
 +\"dhcp4o6-port\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_DHCP4O6_PORT(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("dhcp4o6-port", driver.loc_);
 +    }
 +}
 +
 +\"version\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_VERSION(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("version", driver.loc_);
 +    }
 +}
 +
 +\"control-socket\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_CONTROL_SOCKET(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("control-socket", driver.loc_);
 +    }
 +}
 +
 +\"socket-type\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CONTROL_SOCKET:
 +        return isc::dhcp::Dhcp4Parser::make_SOCKET_TYPE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("socket-type", driver.loc_);
 +    }
 +}
 +
 +\"socket-name\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CONTROL_SOCKET:
 +        return isc::dhcp::Dhcp4Parser::make_SOCKET_NAME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("socket-name", driver.loc_);
 +    }
 +}
 +
 +\"dhcp-ddns\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +        return isc::dhcp::Dhcp4Parser::make_DHCP_DDNS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("dhcp-ddns", driver.loc_);
 +    }
 +}
 +
 +\"Dhcp6\"  {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CONFIG:
 +        return isc::dhcp::Dhcp4Parser::make_DHCP6(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("Dhcp6", driver.loc_);
 +    }
 +}
 +
 +\"DhcpDdns\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::CONFIG:
 +        return isc::dhcp::Dhcp4Parser::make_DHCPDDNS(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("DhcpDdns", driver.loc_);
 +    }
 +}
 +
 +\"4o6-interface\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_SUBNET_4O6_INTERFACE(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("4o6-interface", driver.loc_);
 +    }
 +}
 +
 +\"4o6-interface-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_SUBNET_4O6_INTERFACE_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("4o6-interface-id", driver.loc_);
 +    }
 +}
 +
 +\"4o6-subnet\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_SUBNET_4O6_SUBNET(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("4o6-interface", driver.loc_);
 +    }
 +}
 +
 +\"echo-client-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_ECHO_CLIENT_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("echo-client-id", driver.loc_);
 +    }
 +}
 +
 +\"match-client-id\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +        return isc::dhcp::Dhcp4Parser::make_MATCH_CLIENT_ID(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("match-client-id", driver.loc_);
 +    }
 +}
 +
 +\"next-server\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::DHCP4:
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +        return isc::dhcp::Dhcp4Parser::make_NEXT_SERVER(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("next-server", driver.loc_);
 +    }
 +}
 +
 +\"server-hostname\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +        return isc::dhcp::Dhcp4Parser::make_SERVER_HOSTNAME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("server-hostname", driver.loc_);
 +    }
 +}
 +
 +\"boot-file-name\" {
 +    switch(driver.ctx_) {
 +    case isc::dhcp::Parser4Context::SUBNET4:
 +    case isc::dhcp::Parser4Context::RESERVATIONS:
 +    case isc::dhcp::Parser4Context::CLIENT_CLASSES:
 +        return isc::dhcp::Dhcp4Parser::make_BOOT_FILE_NAME(driver.loc_);
 +    default:
 +        return isc::dhcp::Dhcp4Parser::make_STRING("boot-file-name", driver.loc_);
 +    }
 +}
 +
 +
 +
 +{JSONString} {
 +    // A string has been matched. It contains the actual string and single quotes.
 +    // We need to get those quotes out of the way and just use its content, e.g.
 +    // for 'foo' we should get foo
 +    std::string raw(yytext+1);
 +    size_t len = raw.size() - 1;
 +    raw.resize(len);
 +    std::string decoded;
 +    decoded.reserve(len);
 +    for (size_t pos = 0; pos < len; ++pos) {
++        int b = 0;
 +        char c = raw[pos];
 +        switch (c) {
 +        case '"':
 +            // impossible condition
 +            driver.error(driver.loc_, "Bad quote in \"" + raw + "\"");
 +        case '\\':
 +            ++pos;
 +            if (pos >= len) {
 +                // impossible condition
 +                driver.error(driver.loc_, "Overflow escape in \"" + raw + "\"");
 +            }
 +            c = raw[pos];
 +            switch (c) {
 +            case '"':
 +            case '\\':
 +            case '/':
 +                decoded.push_back(c);
 +                break;
 +            case 'b':
 +                decoded.push_back('\b');
 +                break;
 +            case 'f':
 +                decoded.push_back('\f');
 +                break;
 +            case 'n':
 +                decoded.push_back('\n');
 +                break;
 +            case 'r':
 +                decoded.push_back('\r');
 +                break;
 +            case 't':
 +                decoded.push_back('\t');
 +                break;
 +            case 'u':
++                // support only \u0000 to \u00ff
++                ++pos;
++                if (pos + 4 > len) {
++                    // impossible condition
++                    driver.error(driver.loc_,
++                                 "Overflow unicode escape in \"" + raw + "\"");
++                }
++                if ((raw[pos] != '0') || (raw[pos + 1] != '0')) {
++                    driver.error(driver.loc_, "Unsupported unicode escape in \"" + raw + "\"");
++                }
++                pos += 2;
++                c = raw[pos];
++                if ((c >= '0') && (c <= '9')) {
++                    b = (c - '0') << 4;
++                } else if ((c >= 'A') && (c <= 'F')) {
++                    b = (c - 'A' + 10) << 4;
++                } else if ((c >= 'a') && (c <= 'f')) {
++                    b = (c - 'a' + 10) << 4;
++                } else {
++                    // impossible condition
++                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
++                }
++                pos++;
++                c = raw[pos];
++                if ((c >= '0') && (c <= '9')) {
++                    b |= c - '0';
++                } else if ((c >= 'A') && (c <= 'F')) {
++                    b |= c - 'A' + 10;
++                } else if ((c >= 'a') && (c <= 'f')) {
++                    b |= c - 'a' + 10;
++                } else {
++                    // impossible condition
++                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
++                }
++                decoded.push_back(static_cast<char>(b & 0xff));
++                break;
 +            default:
 +                // impossible condition
 +                driver.error(driver.loc_, "Bad escape in \"" + raw + "\"");
 +            }
 +            break;
 +        default:
 +            if ((c >= 0) && (c < 0x20)) {
 +                // impossible condition
 +                driver.error(driver.loc_, "Invalid control in \"" + raw + "\"");
 +            }
 +            decoded.push_back(c);
 +        }
 +    }
 +
 +    return isc::dhcp::Dhcp4Parser::make_STRING(decoded, driver.loc_);
 +}
 +
 +\"{JSONStringCharacter}*{ControlCharacter}{ControlCharacterFill}*\" {
 +    // Bad string with a forbidden control character inside
 +    driver.error(driver.loc_, "Invalid control in " + std::string(yytext));
 +}
 +
 +\"{JSONStringCharacter}*\\{BadJSONEscapeSequence}[^\x00-\x1f"]*\" {
 +    // Bad string with a bad escape inside
 +    driver.error(driver.loc_, "Bad escape in " + std::string(yytext));
 +}
 +
 +\"{JSONStringCharacter}*\\\" {
 +    // Bad string with an open escape at the end
 +    driver.error(driver.loc_, "Overflow escape in " + std::string(yytext));
 +}
 +
 +"["    { return isc::dhcp::Dhcp4Parser::make_LSQUARE_BRACKET(driver.loc_); }
 +"]"    { return isc::dhcp::Dhcp4Parser::make_RSQUARE_BRACKET(driver.loc_); }
 +"{"    { return isc::dhcp::Dhcp4Parser::make_LCURLY_BRACKET(driver.loc_); }
 +"}"    { return isc::dhcp::Dhcp4Parser::make_RCURLY_BRACKET(driver.loc_); }
 +","    { return isc::dhcp::Dhcp4Parser::make_COMMA(driver.loc_); }
 +":"    { return isc::dhcp::Dhcp4Parser::make_COLON(driver.loc_); }
 +
 +{int} {
 +    // An integer was found.
 +    std::string tmp(yytext);
 +    int64_t integer = 0;
 +    try {
 +        // In substring we want to use negative values (e.g. -1).
 +        // In enterprise-id we need to use values up to 0xffffffff.
 +        // To cover both of those use cases, we need at least
 +        // int64_t.
 +        integer = boost::lexical_cast<int64_t>(tmp);
 +    } catch (const boost::bad_lexical_cast &) {
 +        driver.error(driver.loc_, "Failed to convert " + tmp + " to an integer.");
 +    }
 +
 +    // The parser needs the string form as double conversion is no lossless
 +    return isc::dhcp::Dhcp4Parser::make_INTEGER(integer, driver.loc_);
 +}
 +
 +[-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)? {
 +    // A floating point was found.
 +    std::string tmp(yytext);
 +    double fp = 0.0;
 +    try {
 +        fp = boost::lexical_cast<double>(tmp);
 +    } catch (const boost::bad_lexical_cast &) {
 +        driver.error(driver.loc_, "Failed to convert " + tmp + " to a floating point.");
 +    }
 +
 +    return isc::dhcp::Dhcp4Parser::make_FLOAT(fp, driver.loc_);
 +}
 +
 +true|false {
 +    string tmp(yytext);
 +    return isc::dhcp::Dhcp4Parser::make_BOOLEAN(tmp == "true", driver.loc_);
 +}
 +
 +null {
 +   return isc::dhcp::Dhcp4Parser::make_NULL_TYPE(driver.loc_);
 +}
 +
++(?i:true) driver.error (driver.loc_, "JSON true reserved keyword is lower case only");
++
++(?i:false) driver.error (driver.loc_, "JSON false reserved keyword is lower case only");
++
++(?i:null) driver.error (driver.loc_, "JSON null reserved keyword is lower case only");
++
 +<*>.   driver.error (driver.loc_, "Invalid character: " + std::string(yytext));
 +
 +<<EOF>> {
 +    if (driver.states_.empty()) {
 +        return isc::dhcp::Dhcp4Parser::make_END(driver.loc_);
 +    }
 +    driver.loc_ = driver.locs_.back();
 +    driver.locs_.pop_back();
 +    driver.file_ = driver.files_.back();
 +    driver.files_.pop_back();
 +    if (driver.sfile_) {
 +        fclose(driver.sfile_);
 +        driver.sfile_ = 0;
 +    }
 +    if (!driver.sfiles_.empty()) {
 +        driver.sfile_ = driver.sfiles_.back();
 +        driver.sfiles_.pop_back();
 +    }
 +    parser4__delete_buffer(YY_CURRENT_BUFFER);
 +    parser4__switch_to_buffer(driver.states_.back());
 +    driver.states_.pop_back();
 +
 +    BEGIN(DIR_EXIT);
 +}
 +
 +%%
 +
 +using namespace isc::dhcp;
 +
 +void
 +Parser4Context::scanStringBegin(const std::string& str, ParserType parser_type)
 +{
 +    start_token_flag = true;
 +    start_token_value = parser_type;
 +
 +    file_ = "<string>";
 +    sfile_ = 0;
 +    loc_.initialize(&file_);
 +    yy_flex_debug = trace_scanning_;
 +    YY_BUFFER_STATE buffer;
 +    buffer = yy_scan_bytes(str.c_str(), str.size());
 +    if (!buffer) {
 +        fatal("cannot scan string");
 +        // fatal() throws an exception so this can't be reached
 +    }
 +}
 +
 +void
 +Parser4Context::scanFileBegin(FILE * f,
 +                              const std::string& filename,
 +                              ParserType parser_type)
 +{
 +    start_token_flag = true;
 +    start_token_value = parser_type;
 +
 +    file_ = filename;
 +    sfile_ = f;
 +    loc_.initialize(&file_);
 +    yy_flex_debug = trace_scanning_;
 +    YY_BUFFER_STATE buffer;
 +
 +    // See dhcp4_lexer.cc header for available definitions
 +    buffer = parser4__create_buffer(f, 65536 /*buffer size*/);
 +    if (!buffer) {
 +        fatal("cannot scan file " + filename);
 +    }
 +    parser4__switch_to_buffer(buffer);
 +}
 +
 +void
 +Parser4Context::scanEnd() {
 +    if (sfile_)
 +        fclose(sfile_);
 +    sfile_ = 0;
 +    static_cast<void>(parser4_lex_destroy());
 +    // Close files
 +    while (!sfiles_.empty()) {
 +        FILE* f = sfiles_.back();
 +        if (f) {
 +            fclose(f);
 +        }
 +        sfiles_.pop_back();
 +    }
 +    // Delete states
 +    while (!states_.empty()) {
 +        parser4__delete_buffer(states_.back());
 +        states_.pop_back();
 +    }
 +}
 +
 +void
 +Parser4Context::includeFile(const std::string& filename) {
 +    if (states_.size() > 10) {
 +        fatal("Too many nested include.");
 +    }
 +
 +    FILE* f = fopen(filename.c_str(), "r");
 +    if (!f) {
 +        fatal("Can't open include file " + filename);
 +    }
 +    if (sfile_) {
 +        sfiles_.push_back(sfile_);
 +    }
 +    sfile_ = f;
 +    states_.push_back(YY_CURRENT_BUFFER);
 +    YY_BUFFER_STATE buffer;
 +    buffer = parser4__create_buffer(f, 65536 /*buffer size*/);
 +    if (!buffer) {
 +        fatal( "Can't scan include file " + filename);
 +    }
 +    parser4__switch_to_buffer(buffer);
 +    files_.push_back(file_);
 +    file_ = filename;
 +    locs_.push_back(loc_);
 +    loc_.initialize(&file_);
 +
 +    BEGIN(INITIAL);
 +}
 +
 +namespace {
 +/// To avoid unused function error
 +class Dummy {
 +    // cppcheck-suppress unusedPrivateFunction
 +    void dummy() { yy_fatal_error("Fix me: how to disable its definition?"); }
 +};
 +}

diff --cc src/bin/dhcp4/tests/parser_unittest.cc
index 73c5897465f8ce4f959c40e45e719c81008e3619,0000000000000000000000000000000000000000..807552a13c042365ca47aeb9b2ad293ee760e1c5
mode 100644,000000..100644
--- 1/src/bin/dhcp4/tests/parser_unittest.cc
--- /dev/null
+++ b/src/bin/dhcp4/tests/parser_unittest.cc
@@@ -1,472 -1,0 +1,518 @@@
-         Parser4Context ctx;
-         test_json = ctx.parseString(txt, parser_type);
 +// Copyright (C) 2016 Internet Systems Consortium, Inc. ("ISC")
 +//
 +// This Source Code Form is subject to the terms of the Mozilla Public
 +// License, v. 2.0. If a copy of the MPL was not distributed with this
 +// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 +
 +#include <gtest/gtest.h>
 +#include <cc/data.h>
 +#include <dhcp4/parser_context.h>
 +
 +using namespace isc::data;
 +using namespace std;
 +
 +namespace {
 +
 +void compareJSON(ConstElementPtr a, ConstElementPtr b, bool print = true) {
 +    ASSERT_TRUE(a);
 +    ASSERT_TRUE(b);
 +    if (print) {
 +        // std::cout << "JSON A: -----" << endl << a->str() << std::endl;
 +        // std::cout << "JSON B: -----" << endl << b->str() << std::endl;
 +        // cout << "---------" << endl << endl;
 +    }
 +    EXPECT_EQ(a->str(), b->str());
 +}
 +
 +void testParser(const std::string& txt, Parser4Context::ParserType parser_type) {
 +    ElementPtr reference_json;
 +    ConstElementPtr test_json;
 +
 +    ASSERT_NO_THROW(reference_json = Element::fromJSON(txt, true));
 +    ASSERT_NO_THROW({
 +            try {
-         Parser4Context ctx;
-         test_json = ctx.parseString(txt, parser_type);
++                Parser4Context ctx;
++                test_json = ctx.parseString(txt, parser_type);
 +            } catch (const std::exception &e) {
 +                cout << "EXCEPTION: " << e.what() << endl;
 +                throw;
 +            }
 +
 +    });
 +
 +    // Now compare if both representations are the same.
 +    compareJSON(reference_json, test_json);
 +}
 +
 +void testParser2(const std::string& txt, Parser4Context::ParserType parser_type) {
 +    ConstElementPtr test_json;
 +
 +    ASSERT_NO_THROW({
 +            try {
-     // case sensitivity
++                Parser4Context ctx;
++                test_json = ctx.parseString(txt, parser_type);
 +            } catch (const std::exception &e) {
 +                cout << "EXCEPTION: " << e.what() << endl;
 +                throw;
 +            }
 +    });
 +    /// @todo: Implement actual validation here. since the original
 +    /// Element::fromJSON does not support several comment types, we don't
 +    /// have anything to compare with.
 +    /// std::cout << "Original text:" << txt << endl;
 +    /// std::cout << "Parsed text  :" << test_json->str() << endl;
 +}
 +
 +TEST(ParserTest, mapInMap) {
 +    string txt = "{ \"xyzzy\": { \"foo\": 123, \"baz\": 456 } }";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, listInList) {
 +    string txt = "[ [ \"Britain\", \"Wales\", \"Scotland\" ], "
 +                 "[ \"Pomorze\", \"Wielkopolska\", \"Tatry\"] ]";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, nestedMaps) {
 +    string txt = "{ \"europe\": { \"UK\": { \"London\": { \"street\": \"221B Baker\" }}}}";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, nestedLists) {
 +    string txt = "[ \"half\", [ \"quarter\", [ \"eighth\", [ \"sixteenth\" ]]]]";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, listsInMaps) {
 +    string txt = "{ \"constellations\": { \"orion\": [ \"rigel\", \"betelguese\" ], "
 +                    "\"cygnus\": [ \"deneb\", \"albireo\"] } }";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, mapsInLists) {
 +    string txt = "[ { \"body\": \"earth\", \"gravity\": 1.0 },"
 +                 " { \"body\": \"mars\", \"gravity\": 0.376 } ]";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, types) {
 +    string txt = "{ \"string\": \"foo\","
 +                   "\"integer\": 42,"
 +                   "\"boolean\": true,"
 +                   "\"map\": { \"foo\": \"bar\" },"
 +                   "\"list\": [ 1, 2, 3 ],"
 +                   "\"null\": null }";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, keywordJSON) {
 +    string txt = "{ \"name\": \"user\","
 +                   "\"type\": \"password\","
 +                   "\"user\": \"name\","
 +                   "\"password\": \"type\" }";
 +    testParser(txt, Parser4Context::PARSER_JSON);
 +}
 +
 +TEST(ParserTest, keywordDhcp4) {
 +     string txt = "{ \"Dhcp4\": { \"interfaces-config\": {"
 +                  " \"interfaces\": [ \"type\", \"htype\" ] },\n"
 +                  "\"rebind-timer\": 2000, \n"
 +                  "\"renew-timer\": 1000, \n"
 +                  "\"subnet4\": [ { "
 +                  "  \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ],"
 +                  "  \"subnet\": \"192.0.2.0/24\", "
 +                  "  \"interface\": \"test\" } ],\n"
 +                   "\"valid-lifetime\": 4000 } }";
 +     testParser2(txt, Parser4Context::PARSER_DHCP4);
 +}
 +
 +TEST(ParserTest, bashComments) {
 +    string txt= "{ \"Dhcp4\": { \"interfaces-config\": {"
 +                "  \"interfaces\": [ \"*\" ]"
 +                "},\n"
 +                "# this is a comment\n"
 +                "\"rebind-timer\": 2000, \n"
 +                "# lots of comments here\n"
 +                "# and here\n"
 +                "\"renew-timer\": 1000, \n"
 +                "\"subnet4\": [ { "
 +                "    \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ],"
 +                "    \"subnet\": \"192.0.2.0/24\", "
 +                "    \"interface\": \"eth0\""
 +                " } ],"
 +                "\"valid-lifetime\": 4000 } }";
 +    testParser2(txt, Parser4Context::PARSER_DHCP4);
 +}
 +
 +TEST(ParserTest, cComments) {
 +    string txt= "{ \"Dhcp4\": { \"interfaces-config\": {"
 +                "  \"interfaces\": [ \"*\" ]"
 +                "},\n"
 +                "\"rebind-timer\": 2000, // everything after // is ignored\n"
 +                "\"renew-timer\": 1000, // this will be ignored, too\n"
 +                "\"subnet4\": [ { "
 +                "    \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ],"
 +                "    \"subnet\": \"192.0.2.0/24\", "
 +                "    \"interface\": \"eth0\""
 +                " } ],"
 +                "\"valid-lifetime\": 4000 } }";
 +    testParser2(txt, Parser4Context::PARSER_DHCP4);
 +}
 +
 +TEST(ParserTest, bashCommentsInline) {
 +    string txt= "{ \"Dhcp4\": { \"interfaces-config\": {"
 +                "  \"interfaces\": [ \"*\" ]"
 +                "},\n"
 +                "\"rebind-timer\": 2000, # everything after # is ignored\n"
 +                "\"renew-timer\": 1000, # this will be ignored, too\n"
 +                "\"subnet4\": [ { "
 +                "    \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ],"
 +                "    \"subnet\": \"192.0.2.0/24\", "
 +                "    \"interface\": \"eth0\""
 +                " } ],"
 +                "\"valid-lifetime\": 4000 } }";
 +    testParser2(txt, Parser4Context::PARSER_DHCP4);
 +}
 +
 +TEST(ParserTest, multilineComments) {
 +    string txt= "{ \"Dhcp4\": { \"interfaces-config\": {"
 +                "  \"interfaces\": [ \"*\" ]"
 +                "},\n"
 +                "   /* this is a C style comment\n"
 +                "that\n can \n span \n multiple \n lines */ \n"
 +                "\"rebind-timer\": 2000,\n"
 +                "\"renew-timer\": 1000, \n"
 +                "\"subnet4\": [ { "
 +                "    \"pools\": [ { \"pool\": \"192.0.2.1 - 192.0.2.100\" } ],"
 +                "    \"subnet\": \"192.0.2.0/24\", "
 +                "    \"interface\": \"eth0\""
 +                " } ],"
 +                "\"valid-lifetime\": 4000 } }";
 +    testParser2(txt, Parser4Context::PARSER_DHCP4);
 +}
 +
 +
 +void testFile(const std::string& fname, bool print) {
 +    ElementPtr reference_json;
 +    ConstElementPtr test_json;
 +
 +    cout << "Attempting to load file " << fname << endl;
 +
 +    EXPECT_NO_THROW(reference_json = Element::fromJSONFile(fname, true));
 +
 +    EXPECT_NO_THROW(
 +    try {
 +        Parser4Context ctx;
 +        test_json = ctx.parseFile(fname, Parser4Context::PARSER_DHCP4);
 +    } catch (const std::exception &x) {
 +        cout << "EXCEPTION: " << x.what() << endl;
 +        throw;
 +    });
 +
 +    ASSERT_TRUE(reference_json);
 +    ASSERT_TRUE(test_json);
 +
 +    compareJSON(reference_json, test_json, print);
 +
 +
 +}
 +
 +// This test loads all available existing files. Each config is loaded
 +// twice: first with the existing Element::fromJSONFile() and then
 +// the second time with Parser4. Both JSON trees are then compared.
 +TEST(ParserTest, file) {
 +    vector<string> configs;
 +    configs.push_back("backends.json");
 +    configs.push_back("classify.json");
 +    configs.push_back("dhcpv4-over-dhcpv6.json");
 +    configs.push_back("hooks.json");
 +    configs.push_back("leases-expiration.json");
 +    configs.push_back("multiple-options.json");
 +    configs.push_back("mysql-reservations.json");
 +    configs.push_back("pgsql-reservations.json");
 +    configs.push_back("reservations.json");
 +    configs.push_back("several-subnets.json");
 +    configs.push_back("single-subnet.json");
 +
 +    for (int i = 0; i<configs.size(); i++) {
 +        testFile(string(CFG_EXAMPLES) + "/" + configs[i], false);
 +    }
 +}
 +
 +void testError(const std::string& txt,
 +               Parser4Context::ParserType parser_type,
 +               const std::string& msg)
 +{
 +    try {
 +        Parser4Context ctx;
 +        ConstElementPtr parsed = ctx.parseString(txt, parser_type);
 +        FAIL() << "Expected Dhcp4ParseError but nothing was raised (expected: "
 +               << msg << ")";
 +    }
 +    catch (const Dhcp4ParseError& ex) {
 +        EXPECT_EQ(msg, ex.what());
 +    }
 +    catch (...) {
 +        FAIL() << "Expected Dhcp4ParseError but something else was raised";
 +    }
 +}
 +
 +// Check errors
 +TEST(ParserTest, errors) {
 +    // no input
 +    testError("", Parser4Context::PARSER_JSON,
 +              "<string>:1.1: syntax error, unexpected end of file");
 +    testError(" ", Parser4Context::PARSER_JSON,
 +              "<string>:1.2: syntax error, unexpected end of file");
 +    testError("\n", Parser4Context::PARSER_JSON,
 +              "<string>:2.1: syntax error, unexpected end of file");
 +    testError("\t", Parser4Context::PARSER_JSON,
 +              "<string>:1.2: syntax error, unexpected end of file");
 +    testError("\r", Parser4Context::PARSER_JSON,
 +              "<string>:1.2: syntax error, unexpected end of file");
 +
 +    // comments
 +    testError("# nothing\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:2.1: syntax error, unexpected end of file");
 +    testError(" #\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:2.1: syntax error, unexpected end of file");
 +    testError("// nothing\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:2.1: syntax error, unexpected end of file");
 +    testError("/* nothing */\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:2.1: syntax error, unexpected end of file");
 +    testError("/* no\nthing */\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:3.1: syntax error, unexpected end of file");
 +    testError("/* no\nthing */\n\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:4.1: syntax error, unexpected end of file");
 +    testError("/* nothing\n",
 +              Parser4Context::PARSER_JSON,
 +              "Comment not closed. (/* in line 1");
 +    testError("\n\n\n/* nothing\n",
 +              Parser4Context::PARSER_JSON,
 +              "Comment not closed. (/* in line 4");
 +    testError("{ /* */*/ }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3-8: Invalid character: *");
 +    testError("{ /* // *// }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3-11: Invalid character: /");
 +    testError("{ /* // *///  }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:2.1: syntax error, unexpected end of file, "
 +              "expecting }");
 +
 +    // includes
 +    testError("<?\n",
 +              Parser4Context::PARSER_JSON,
 +              "Directive not closed.");
 +    testError("<?include\n",
 +              Parser4Context::PARSER_JSON,
 +              "Directive not closed.");
 +    string file = string(CFG_EXAMPLES) + "/" + "single-subnet.json";
 +    testError("<?include \"" + file + "\"\n",
 +              Parser4Context::PARSER_JSON,
 +              "Directive not closed.");
 +    testError("<?include \"/foo/bar\" ?>/n",
 +              Parser4Context::PARSER_JSON,
 +              "Can't open include file /foo/bar");
 +
-     testError("{ \"foo\": NULL  }",
++    // JSON keywords
 +    testError("{ \"foo\": True }",
++              Parser4Context::PARSER_JSON,
++              "<string>:1.10-13: JSON true reserved keyword is lower case only");
++    testError("{ \"foo\": False }",
++              Parser4Context::PARSER_JSON,
++              "<string>:1.10-14: JSON false reserved keyword is lower case only");
++    testError("{ \"foo\": NULL }",
++              Parser4Context::PARSER_JSON,
++              "<string>:1.10-13: JSON null reserved keyword is lower case only");
++    testError("{ \"foo\": Tru }",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.10: Invalid character: T");
-               "<string>:1.10: Invalid character: N");
++    testError("{ \"foo\": nul }",
 +              Parser4Context::PARSER_JSON,
-     testError("\"a\\u0062\"",
++              "<string>:1.10: Invalid character: n");
 +
 +    // numbers
 +    testError("123",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1-3: syntax error, unexpected integer, "
 +              "expecting {");
 +    testError("-456",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1-4: syntax error, unexpected integer, "
 +              "expecting {");
 +    testError("-0001",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1-5: syntax error, unexpected integer, "
 +              "expecting {");
 +    testError("1234567890123456789012345678901234567890",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1-40: Failed to convert "
 +              "1234567890123456789012345678901234567890"
 +              " to an integer.");
 +    testError("-3.14e+0",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1-8: syntax error, unexpected floating point, "
 +              "expecting {");
 +    testError("1e50000",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1-7: Failed to convert 1e50000 "
 +              "to a floating point.");
 +
 +    // strings
 +    testError("\"aabb\"",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1-6: syntax error, unexpected constant string, "
 +              "expecting {");
 +    testError("{ \"aabb\"err",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.9: Invalid character: e");
 +    testError("{ err\"aabb\"",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3: Invalid character: e");
 +    testError("\"a\n\tb\"",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1-6: Invalid control in \"a\n\tb\"");
 +    testError("\"a\\n\\tb\"",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1-8: syntax error, unexpected constant string, "
 +              "expecting {");
 +    testError("\"a\\x01b\"",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1-8: Bad escape in \"a\\x01b\"");
-               "<string>:1.1-9: Unsupported unicode escape in \"a\\u0062\"");
++    testError("\"a\\u0162\"",
 +              Parser4Context::PARSER_JSON,
++              "<string>:1.1-9: Unsupported unicode escape in \"a\\u0162\"");
 +    testError("\"a\\u062z\"",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1-9: Bad escape in \"a\\u062z\"");
 +    testError("\"abc\\\"",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1-6: Overflow escape in \"abc\\\"");
 +
 +    // from data_unittest.c
 +    testError("\\a",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1: Invalid character: \\");
 +    testError("\\",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1: Invalid character: \\");
 +    testError("\\\"\\\"",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.1: Invalid character: \\");
 +
 +    // want a map
 +    testError("[]\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1: syntax error, unexpected [, "
 +              "expecting {");
 +    testError("[]\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.1: syntax error, unexpected [, "
 +              "expecting {");
 +    testError("{ 123 }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3-5: syntax error, unexpected integer, "
 +              "expecting }");
 +    testError("{ 123 }\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.3-5: syntax error, unexpected integer");
 +    testError("{ \"foo\" }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.9: syntax error, unexpected }, "
 +              "expecting :");
 +    testError("{ \"foo\" }\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.9: syntax error, unexpected }, expecting :");
 +    testError("{ \"foo\":null }\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.3-7: got unexpected keyword "
 +              "\"foo\" in toplevel map.");
 +    testError("{ \"Dhcp4\" }\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:1.11: syntax error, unexpected }, "
 +              "expecting :");
 +    testError("{ \"Dhcp6\":[]\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:2.1: syntax error, unexpected end of file, "
 +              "expecting \",\" or }");
 +    testError("{}{}\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3: syntax error, unexpected {, "
 +              "expecting end of file");
 +
 +    // bad commas
 +    testError("{ , }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3: syntax error, unexpected \",\", "
 +              "expecting }");
 +    testError("{ , \"foo\":true }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.3: syntax error, unexpected \",\", "
 +              "expecting }");
 +    testError("{ \"foo\":true, }\n",
 +              Parser4Context::PARSER_JSON,
 +              "<string>:1.15: syntax error, unexpected }, "
 +              "expecting constant string");
 +
 +    // bad type
 +    testError("{ \"Dhcp4\":{\n"
 +              "  \"valid-lifetime\":false }}\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:2.20-24: syntax error, unexpected boolean, "
 +              "expecting integer");
 +
 +    // unknown keyword
 +    testError("{ \"Dhcp4\":{\n"
 +              " \"valid_lifetime\":600 }}\n",
 +              Parser4Context::PARSER_DHCP4,
 +              "<string>:2.2-17: got unexpected keyword "
 +              "\"valid_lifetime\" in Dhcp4 map.");
 +}
 +
++// Check unicode escapes
++TEST(ParserTest, unicodeEscapes) {
++    ConstElementPtr result;
++    string json;
++
++    // check we can reread output
++    for (char c = -128; c < 127; ++c) {
++        string ins(" ");
++        ins[1] = c;
++        ConstElementPtr e(new StringElement(ins));
++        json = e->str();
++        ASSERT_NO_THROW(
++        try {
++            Parser4Context ctx;
++            result = ctx.parseString(json, Parser4Context::PARSER_JSON);
++        } catch (const std::exception &x) {
++            cout << "EXCEPTION: " << x.what() << endl;
++            throw;
++        });
++        ASSERT_EQ(Element::string, result->getType());
++        EXPECT_EQ(ins, result->stringValue());
++    }
++
++    // check the 4 possible encodings of solidus '/'
++    json = "\"/\\/\\u002f\\u002F\"";
++    ASSERT_NO_THROW(
++    try {
++        Parser4Context ctx;
++        result = ctx.parseString(json, Parser4Context::PARSER_JSON);
++    } catch (const std::exception &x) {
++        cout << "EXCEPTION: " << x.what() << endl;
++        throw;
++    });
++    ASSERT_EQ(Element::string, result->getType());
++    EXPECT_EQ("////", result->stringValue());
++}       
++
 +};

diff --cc src/bin/dhcp6/dhcp6_lexer.cc
index 3780d53d4eb5be63f5e66eb65e5c66517e073fe2,b67c1a81d4d06d2aae66403f7aca5e34d69df96e..0000000000000000000000000000000000000000
deleted file mode 100644,100644
--- 1/src/bin/dhcp6/dhcp6_lexer.cc
--- 2/src/bin/dhcp6/dhcp6_lexer.cc
+++ /dev/null
@@@ -1,4019 -1,5074 +1,0 @@@
--#line 2 "dhcp6_lexer.cc"
--
--#line 4 "dhcp6_lexer.cc"
--
--#define  YY_INT_ALIGNED short int
--
--/* A lexical scanner generated by flex */
--
--/* %not-for-header */
--
--/* %if-c-only */
--/* %if-not-reentrant */
--#define yy_create_buffer parser6__create_buffer
--#define yy_delete_buffer parser6__delete_buffer
--#define yy_flex_debug parser6__flex_debug
--#define yy_init_buffer parser6__init_buffer
--#define yy_flush_buffer parser6__flush_buffer
--#define yy_load_buffer_state parser6__load_buffer_state
--#define yy_switch_to_buffer parser6__switch_to_buffer
--#define yyin parser6_in
--#define yyleng parser6_leng
--#define yylex parser6_lex
--#define yylineno parser6_lineno
--#define yyout parser6_out
--#define yyrestart parser6_restart
--#define yytext parser6_text
--#define yywrap parser6_wrap
--#define yyalloc parser6_alloc
--#define yyrealloc parser6_realloc
--#define yyfree parser6_free
--
--/* %endif */
--/* %endif */
--/* %ok-for-header */
--
--#define FLEX_SCANNER
--#define YY_FLEX_MAJOR_VERSION 2
--#define YY_FLEX_MINOR_VERSION 6
- #define YY_FLEX_SUBMINOR_VERSION 0
 -#define YY_FLEX_SUBMINOR_VERSION 1
--#if YY_FLEX_SUBMINOR_VERSION > 0
--#define FLEX_BETA
--#endif
--
--/* %if-c++-only */
--/* %endif */
--
--/* %if-c-only */
--    
--/* %endif */
--
--/* %if-c-only */
--
--/* %endif */
--
--/* First, we deal with  platform-specific or compiler-specific issues. */
--
--/* begin standard C headers. */
--/* %if-c-only */
--#include <stdio.h>
--#include <string.h>
--#include <errno.h>
--#include <stdlib.h>
--/* %endif */
--
--/* %if-tables-serialization */
--/* %endif */
--/* end standard C headers. */
--
--/* %if-c-or-c++ */
--/* flex integer type definitions */
--
--#ifndef FLEXINT_H
--#define FLEXINT_H
--
--/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
--
--#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
--
--/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
-- * if you want the limit (max/min) macros for int types. 
-- */
--#ifndef __STDC_LIMIT_MACROS
--#define __STDC_LIMIT_MACROS 1
--#endif
--
--#include <inttypes.h>
--typedef int8_t flex_int8_t;
--typedef uint8_t flex_uint8_t;
--typedef int16_t flex_int16_t;
--typedef uint16_t flex_uint16_t;
--typedef int32_t flex_int32_t;
--typedef uint32_t flex_uint32_t;
--#else
--typedef signed char flex_int8_t;
--typedef short int flex_int16_t;
--typedef int flex_int32_t;
--typedef unsigned char flex_uint8_t; 
--typedef unsigned short int flex_uint16_t;
--typedef unsigned int flex_uint32_t;
--
--/* Limits of integral types. */
--#ifndef INT8_MIN
--#define INT8_MIN               (-128)
--#endif
--#ifndef INT16_MIN
--#define INT16_MIN              (-32767-1)
--#endif
--#ifndef INT32_MIN
--#define INT32_MIN              (-2147483647-1)
--#endif
--#ifndef INT8_MAX
--#define INT8_MAX               (127)
--#endif
--#ifndef INT16_MAX
--#define INT16_MAX              (32767)
--#endif
--#ifndef INT32_MAX
--#define INT32_MAX              (2147483647)
--#endif
--#ifndef UINT8_MAX
--#define UINT8_MAX              (255U)
--#endif
--#ifndef UINT16_MAX
--#define UINT16_MAX             (65535U)
--#endif
--#ifndef UINT32_MAX
--#define UINT32_MAX             (4294967295U)
--#endif
--
--#endif /* ! C99 */
--
--#endif /* ! FLEXINT_H */
--
--/* %endif */
--
--/* %if-c++-only */
--/* %endif */
- 
- #ifdef __cplusplus
- 
- /* The "const" storage-class-modifier is valid. */
- #define YY_USE_CONST
- 
- #else /* ! __cplusplus */
- 
- /* C99 requires __STDC__ to be defined as 1. */
- #if defined (__STDC__)
- 
- #define YY_USE_CONST
- 
- #endif        /* defined (__STDC__) */
- #endif        /* ! __cplusplus */
--
- #ifdef YY_USE_CONST
 -/* TODO: this is always defined, so inline it */
--#define yyconst const
 -
 -#if defined(__GNUC__) && __GNUC__ >= 3
 -#define yynoreturn __attribute__((__noreturn__))
--#else
- #define yyconst
 -#define yynoreturn
--#endif
--
--/* %not-for-header */
--
--/* Returned upon end-of-file. */
--#define YY_NULL 0
--/* %ok-for-header */
--
--/* %not-for-header */
--
--/* Promotes a possibly negative, possibly signed char to an unsigned
-- * integer for use as an array index.  If the signed char is negative,
-- * we want to instead treat it as an 8-bit unsigned char, hence the
-- * double cast.
-- */
--#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
--/* %ok-for-header */
--
--/* %if-reentrant */
--/* %endif */
--
--/* %if-not-reentrant */
--
--/* %endif */
--
--/* Enter a start condition.  This macro really ought to take a parameter,
-- * but we do it the disgusting crufty way forced on us by the ()-less
-- * definition of BEGIN.
-- */
--#define BEGIN (yy_start) = 1 + 2 *
--
--/* Translate the current start state into a value that can be later handed
-- * to BEGIN to return to the state.  The YYSTATE alias is for lex
-- * compatibility.
-- */
--#define YY_START (((yy_start) - 1) / 2)
--#define YYSTATE YY_START
--
--/* Action number for EOF rule of a given start state. */
--#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
--
--/* Special action meaning "start processing a new file". */
--#define YY_NEW_FILE parser6_restart(parser6_in  )
--
--#define YY_END_OF_BUFFER_CHAR 0
--
--/* Size of default input buffer. */
--#ifndef YY_BUF_SIZE
--#ifdef __ia64__
--/* On IA-64, the buffer size is 16k, not 8k.
-- * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
-- * Ditto for the __ia64__ case accordingly.
-- */
--#define YY_BUF_SIZE 32768
--#else
--#define YY_BUF_SIZE 16384
--#endif /* __ia64__ */
--#endif
--
--/* The state buf must be large enough to hold one state per character in the main buffer.
-- */
--#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
--
--#ifndef YY_TYPEDEF_YY_BUFFER_STATE
--#define YY_TYPEDEF_YY_BUFFER_STATE
--typedef struct yy_buffer_state *YY_BUFFER_STATE;
--#endif
--
--#ifndef YY_TYPEDEF_YY_SIZE_T
--#define YY_TYPEDEF_YY_SIZE_T
--typedef size_t yy_size_t;
--#endif
--
--/* %if-not-reentrant */
- extern yy_size_t parser6_leng;
 -extern int parser6_leng;
--/* %endif */
--
--/* %if-c-only */
--/* %if-not-reentrant */
--extern FILE *parser6_in, *parser6_out;
--/* %endif */
--/* %endif */
--
--#define EOB_ACT_CONTINUE_SCAN 0
--#define EOB_ACT_END_OF_FILE 1
--#define EOB_ACT_LAST_MATCH 2
--
--    #define YY_LESS_LINENO(n)
--    #define YY_LINENO_REWIND_TO(ptr)
--    
--/* Return all but the first "n" matched characters back to the input stream. */
--#define yyless(n) \
--      do \
--              { \
--              /* Undo effects of setting up parser6_text. */ \
--        int yyless_macro_arg = (n); \
--        YY_LESS_LINENO(yyless_macro_arg);\
--              *yy_cp = (yy_hold_char); \
--              YY_RESTORE_YY_MORE_OFFSET \
--              (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
--              YY_DO_BEFORE_ACTION; /* set up parser6_text again */ \
--              } \
--      while ( 0 )
--
--#define unput(c) yyunput( c, (yytext_ptr)  )
--
--#ifndef YY_STRUCT_YY_BUFFER_STATE
--#define YY_STRUCT_YY_BUFFER_STATE
--struct yy_buffer_state
--      {
--/* %if-c-only */
--      FILE *yy_input_file;
--/* %endif */
--
--/* %if-c++-only */
--/* %endif */
--
--      char *yy_ch_buf;                /* input buffer */
--      char *yy_buf_pos;               /* current position in input buffer */
--
--      /* Size of input buffer in bytes, not including room for EOB
--       * characters.
--       */
-       yy_size_t yy_buf_size;
 -      int yy_buf_size;
--
--      /* Number of characters read into yy_ch_buf, not including EOB
--       * characters.
--       */
--      int yy_n_chars;
--
--      /* Whether we "own" the buffer - i.e., we know we created it,
--       * and can realloc() it to grow it, and should free() it to
--       * delete it.
--       */
--      int yy_is_our_buffer;
--
--      /* Whether this is an "interactive" input source; if so, and
--       * if we're using stdio for input, then we want to use getc()
--       * instead of fread(), to make sure we stop fetching input after
--       * each newline.
--       */
--      int yy_is_interactive;
--
--      /* Whether we're considered to be at the beginning of a line.
--       * If so, '^' rules will be active on the next match, otherwise
--       * not.
--       */
--      int yy_at_bol;
--
--    int yy_bs_lineno; /**< The line count. */
--    int yy_bs_column; /**< The column count. */
--    
--      /* Whether to try to fill the input buffer when we reach the
--       * end of it.
--       */
--      int yy_fill_buffer;
--
--      int yy_buffer_status;
--
--#define YY_BUFFER_NEW 0
--#define YY_BUFFER_NORMAL 1
--      /* When an EOF's been seen but there's still some text to process
--       * then we mark the buffer as YY_EOF_PENDING, to indicate that we
--       * shouldn't try reading from the input source any more.  We might
--       * still have a bunch of tokens to match, though, because of
--       * possible backing-up.
--       *
--       * When we actually see the EOF, we change the status to "new"
--       * (via parser6_restart()), so that the user can continue scanning by
--       * just pointing parser6_in at a new input file.
--       */
--#define YY_BUFFER_EOF_PENDING 2
--
--      };
--#endif /* !YY_STRUCT_YY_BUFFER_STATE */
--
--/* %if-c-only Standard (non-C++) definition */
--/* %not-for-header */
--
--/* %if-not-reentrant */
--
--/* Stack of input buffers. */
--static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
--static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
- static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
 -static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
--/* %endif */
--/* %ok-for-header */
--
--/* %endif */
--
--/* We provide macros for accessing buffer states in case in the
-- * future we want to put the buffer states in a more general
-- * "scanner state".
-- *
-- * Returns the top of the stack, or NULL.
-- */
--#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
--                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
--                          : NULL)
--
--/* Same as previous macro, but useful when we know that the buffer stack is not
-- * NULL or when we need an lvalue. For internal use only.
-- */
--#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
--
--/* %if-c-only Standard (non-C++) definition */
--
--/* %if-not-reentrant */
--/* %not-for-header */
--
--/* yy_hold_char holds the character lost when parser6_text is formed. */
--static char yy_hold_char;
--static int yy_n_chars;                /* number of characters read into yy_ch_buf */
- yy_size_t parser6_leng;
 -int parser6_leng;
--
--/* Points to current character in buffer. */
- static char *yy_c_buf_p = (char *) 0;
 -static char *yy_c_buf_p = NULL;
--static int yy_init = 0;               /* whether we need to initialize */
--static int yy_start = 0;      /* start state number */
--
--/* Flag which is used to allow parser6_wrap()'s to do buffer switches
-- * instead of setting up a fresh parser6_in.  A bit of a hack ...
-- */
--static int yy_did_buffer_switch_on_eof;
--/* %ok-for-header */
--
--/* %endif */
--
--void parser6_restart (FILE *input_file  );
--void parser6__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
--YY_BUFFER_STATE parser6__create_buffer (FILE *file,int size  );
--void parser6__delete_buffer (YY_BUFFER_STATE b  );
--void parser6__flush_buffer (YY_BUFFER_STATE b  );
--void parser6_push_buffer_state (YY_BUFFER_STATE new_buffer  );
--void parser6_pop_buffer_state (void );
--
--static void parser6_ensure_buffer_stack (void );
--static void parser6__load_buffer_state (void );
--static void parser6__init_buffer (YY_BUFFER_STATE b,FILE *file  );
--
--#define YY_FLUSH_BUFFER parser6__flush_buffer(YY_CURRENT_BUFFER )
--
--YY_BUFFER_STATE parser6__scan_buffer (char *base,yy_size_t size  );
--YY_BUFFER_STATE parser6__scan_string (yyconst char *yy_str  );
- YY_BUFFER_STATE parser6__scan_bytes (yyconst char *bytes,yy_size_t len  );
 -YY_BUFFER_STATE parser6__scan_bytes (yyconst char *bytes,int len  );
--
--/* %endif */
--
--void *parser6_alloc (yy_size_t  );
--void *parser6_realloc (void *,yy_size_t  );
--void parser6_free (void *  );
--
--#define yy_new_buffer parser6__create_buffer
--
--#define yy_set_interactive(is_interactive) \
--      { \
--      if ( ! YY_CURRENT_BUFFER ){ \
--        parser6_ensure_buffer_stack (); \
--              YY_CURRENT_BUFFER_LVALUE =    \
--            parser6__create_buffer(parser6_in,YY_BUF_SIZE ); \
--      } \
--      YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
--      }
--
--#define yy_set_bol(at_bol) \
--      { \
--      if ( ! YY_CURRENT_BUFFER ){\
--        parser6_ensure_buffer_stack (); \
--              YY_CURRENT_BUFFER_LVALUE =    \
--            parser6__create_buffer(parser6_in,YY_BUF_SIZE ); \
--      } \
--      YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
--      }
--
--#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
--
--/* %% [1.0] parser6_text/parser6_in/parser6_out/yy_state_type/parser6_lineno etc. def's & init go here */
--/* Begin user sect3 */
--
--#define parser6_wrap() (/*CONSTCOND*/1)
--#define YY_SKIP_YYWRAP
--
--#define FLEX_DEBUG
--
--typedef unsigned char YY_CHAR;
--
- FILE *parser6_in = (FILE *) 0, *parser6_out = (FILE *) 0;
 -FILE *parser6_in = NULL, *parser6_out = NULL;
--
--typedef int yy_state_type;
--
--extern int parser6_lineno;
--
--int parser6_lineno = 1;
--
--extern char *parser6_text;
--#ifdef yytext_ptr
--#undef yytext_ptr
--#endif
--#define yytext_ptr parser6_text
--
--/* %% [1.5] DFA */
--
--/* %if-c-only Standard (non-C++) definition */
--
--static yy_state_type yy_get_previous_state (void );
--static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
--static int yy_get_next_buffer (void );
- #if defined(__GNUC__) && __GNUC__ >= 3
- __attribute__((__noreturn__))
- #endif
- static void yy_fatal_error (yyconst char msg[]  );
 -static void yynoreturn yy_fatal_error (yyconst char* msg  );
--
--/* %endif */
--
--/* Done after the current pattern has been matched and before the
-- * corresponding action - sets up parser6_text.
-- */
--#define YY_DO_BEFORE_ACTION \
--      (yytext_ptr) = yy_bp; \
--/* %% [2.0] code to fiddle parser6_text and parser6_leng for yymore() goes here \ */\
-       parser6_leng = (size_t) (yy_cp - yy_bp); \
 -      parser6_leng = (int) (yy_cp - yy_bp); \
--      (yy_hold_char) = *yy_cp; \
--      *yy_cp = '\0'; \
--/* %% [3.0] code to copy yytext_ptr to parser6_text[] goes here, if %array \ */\
--      (yy_c_buf_p) = yy_cp;
--
--/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */
- #define YY_NUM_RULES 106
- #define YY_END_OF_BUFFER 107
 -#define YY_NUM_RULES 109
 -#define YY_END_OF_BUFFER 110
--/* This struct is not used in this scanner,
--   but its presence is necessary. */
--struct yy_trans_info
--      {
--      flex_int32_t yy_verify;
--      flex_int32_t yy_nxt;
--      };
- static yyconst flex_int16_t yy_accept[759] =
 -static yyconst flex_int16_t yy_accept[773] =
--    {   0,
--      102,  102,    0,    0,    0,    0,    0,    0,    0,    0,
-       107,  105,   10,   11,  105,    1,  102,   99,  102,  102,
-       105,  101,  100,  105,  105,   95,   96,  105,  105,  105,
-        97,   98,    5,    5,    5,  105,  105,  105,   10,   11,
-         0,    0,   91,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    1,  102,  102,    0,  101,  102,    3,    2,
-         6,    0,  102,    0,    0,    0,    4,    0,    0,    9,
-         0,   92,    0,    0,    0,    0,   94,    0,    0,    0,
 -      110,  108,   10,   11,  108,    1,  102,   99,  102,  102,
 -      108,  101,  100,  108,  108,  108,  108,  108,   95,   96,
 -      108,  108,  108,   97,   98,    5,    5,    5,  108,  108,
 -      108,   10,   11,    0,    0,   91,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    1,  102,  102,    0,  101,
 -      102,    3,    2,    6,    0,  102,    0,    0,    0,    0,
 -        0,    0,    4,    0,    0,    9,    0,   92,    0,    0,
 -        0,    0,   94,    0,    0,    0,    0,    0,    0,    0,
--
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,    0,    0,    2,
-         0,    0,    0,    0,    8,    0,    0,    0,    0,   93,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    2,    0,    0,    0,    0,
 -        0,    0,    0,    8,    0,    0,    0,    0,   93,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        45,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,    0,   45,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,  104,  103,    0,
- 
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -
 -        0,    0,    0,    0,    0,    0,  107,  105,    0,  104,
 -      103,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,   48,    0,    0,
-        33,    0,    0,    0,    0,    0,   64,    0,    0,    0,
-         0,    0,   21,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,   32,    0,    0,    0,
 -      106,  103,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,   48,    0,    0,   33,    0,    0,    0,    0,    0,
 -       64,    0,    0,    0,    0,    0,   21,    0,    0,    0,
--
-         0,    0,    0,   41,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,    0,    0,   60,
-        80,   18,   19,    0,    0,    0,    0,   89,   12,    0,
-         0,   71,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,    0,   79,    0,
-         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,   34,    0,    0,    0,    0,    0,
-         0,   72,    0,    0,    0,    0,    0,    0,   67,    0,
-         0,    0,    7,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
- 
 -       32,    0,    0,    0,    0,    0,    0,   41,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,   55,    0,    0,    0,    0,    0,    0,   36,    0,
 -        0,    0,    0,   60,   80,   18,   19,    0,    0,    0,
 -        0,   89,   12,    0,    0,   71,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,   42,    0,    0,    0,    0,   52,    0,    0,    0,
 -        0,    0,   79,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,   34,    0,
 -        0,    0,    0,    0,    0,   72,    0,    0,    0,    0,
 -        0,    0,   67,    0,    0,    0,    7,    0,    0,    0,
 -
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,    0,    0,   76,
-        53,    0,    0,    0,    0,    0,    0,   22,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,   29,    0,   84,   90,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,   55,    0,    0,    0,    0,
 -        0,    0,   36,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,   42,    0,    0,    0,    0,
 -       52,    0,    0,    0,    0,    0,    0,    0,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,   76,   53,    0,    0,    0,    0,    0,
 -        0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,   29,    0,   84,   90,
--
-        66,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,   20,   35,    0,    0,   63,    0,   17,
-         0,    0,    0,    0,    0,    0,   57,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,   88,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,    0,   43,    0,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,   77,    0,    0,    0,
-         0,    0,   68,   56,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,   65,   78,    0,   14,    0,   73,
-         0,    0,    0,    0,    0,   30,    0,   75,    0,   37,
 -        0,    0,    0,    0,   66,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,   20,   35,    0,
 -        0,   63,    0,   17,    0,    0,    0,    0,    0,    0,
 -       57,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -       88,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,   43,    0,    0,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -       77,    0,    0,    0,    0,    0,   68,   56,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,   65,   78,
--
 -        0,   14,    0,   73,    0,    0,    0,    0,    0,   30,
 -        0,   75,    0,   37,    0,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,   70,    0,
--        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,   70,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,    0,   49,   31,    0,    0,
-         0,    0,    0,    0,   26,    0,    0,   87,   86,    0,
-        59,    0,    0,    0,    0,   83,    0,    0,    0,    0,
-         0,    0,   44,    0,   62,    0,   23,    0,    0,   46,
-        27,   69,    0,    0,   61,    0,    0,    0,    0,   40,
-        81,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,   58,   85,    0,    0,    0,    0,    0,
-        16,    0,   15,   54,    0,    0,    0,   25,    0,   38,
 -       49,   31,    0,    0,    0,    0,    0,    0,   26,    0,
 -        0,   87,   86,    0,   59,    0,    0,    0,    0,   83,
 -        0,    0,    0,    0,    0,    0,   44,    0,   62,    0,
 -       23,    0,    0,   46,   27,   69,    0,    0,   61,    0,
 -        0,    0,    0,   40,   81,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,   58,   85,    0,
--
-         0,    0,   74,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,   47,    0,    0,    0,    0,
-        13,    0,    0,    0,    0,    0,    0,   24,    0,    0,
-        39,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-         0,    0,    0,    0,    0,   50,    0,    0,    0,   28,
-         0,    0,   82,    0,    0,    0,   51,    0
 -        0,    0,    0,    0,   16,    0,   15,   54,    0,    0,
 -        0,   25,    0,   38,    0,    0,   74,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,    0,   47,
 -        0,    0,    0,    0,   13,    0,    0,    0,    0,    0,
 -        0,   24,    0,    0,   39,    0,    0,    0,    0,    0,
 -        0,    0,    0,    0,    0,    0,    0,    0,    0,   50,
 -        0,    0,    0,   28,    0,    0,   82,    0,    0,    0,
 -       51,    0
--    } ;
--
--static yyconst YY_CHAR yy_ec[256] =
--    {   0,
--        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
--        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
--        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
--        1,    4,    5,    6,    7,    5,    5,    5,    5,    5,
--        5,    8,    9,   10,   11,   12,   13,   14,   14,   14,
--       14,   15,   14,   16,   14,   14,   14,   17,    5,   18,
-         5,   19,   20,    5,   21,   21,   21,   22,   23,   21,
-         5,    5,    5,    5,    5,   24,    5,    5,    5,    5,
-         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
-        25,   26,   27,    5,   28,    5,   29,   30,   31,   32,
 -        5,   19,   20,    5,   21,   22,   22,   23,   24,   25,
 -        5,    5,    5,    5,    5,   26,    5,   27,    5,    5,
 -        5,   28,   29,   30,   31,    5,    5,    5,    5,    5,
 -       32,   33,   34,    5,   35,    5,   36,   37,   38,   39,
--
-        33,   34,   35,   36,   37,    5,   38,   39,   40,   41,
-        42,   43,    5,   44,   45,   46,   47,   48,   49,   50,
-        51,    5,   52,    5,   53,    5,    5,    5,    5,    5,
 -       40,   41,   42,   43,   44,    5,   45,   46,   47,   48,
 -       49,   50,    5,   51,   52,   53,   54,   55,   56,   57,
 -       58,    5,   59,    5,   60,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
--        5,    5,    5,    5,    5
--    } ;
--
- static yyconst YY_CHAR yy_meta[54] =
 -static yyconst YY_CHAR yy_meta[61] =
--    {   0,
--        1,    1,    2,    3,    3,    4,    3,    3,    3,    3,
--        3,    3,    5,    6,    6,    6,    3,    3,    3,    3,
-         6,    6,    6,    3,    3,    5,    3,    3,    6,    7,
-         6,    6,    6,    7,    3,    3,    3,    3,    3,    3,
-         5,    3,    3,    5,    3,    5,    5,    3,    3,    3,
-         3,    3,    3
 -        6,    6,    6,    6,    6,    3,    3,    3,    3,    3,
 -        3,    3,    5,    3,    3,    6,    7,    6,    6,    6,
 -        7,    3,    3,    3,    3,    3,    3,    5,    3,    3,
 -        5,    3,    5,    5,    3,    3,    3,    3,    3,    3
--    } ;
--
- static yyconst flex_uint16_t yy_base[771] =
 -static yyconst flex_uint16_t yy_base[786] =
--    {   0,
-         0,    0,   52,   55,   58,    0,   56,   60,   41,   57,
-      1021, 1022,   78, 1017,  111,    0,  153, 1022,  158,   73,
-        71,  173, 1022,  999,  168, 1022, 1022,  989,  970,  972,
-      1022, 1022, 1022,   96, 1002,  973,    0,  994,   99, 1009,
-       169,  185, 1022,  975,  968,  228,  965,   63,  161,  130,
-       156,  160,  178,  979,  978,   43,  206,  171,  204,  212,
-       961,  190,    0,  245,  265,  275,  280,  250, 1022,    0,
-      1022,  228,  241,  966,  965,  956, 1022,  971,  995, 1022,
-       187, 1022,  953,  968,  963,  991,    0,  300,  952,  958,
-       235,  946,  947,  269,  961,  954,  239,  135,  259,  939,
 -        0,    0,   59,   62,   65,    0,   63,   67,   64,   66,
 -      268, 5629,   83,  258,  125,    0,  105, 5629,  120,  126,
 -       80,  169, 5629,  227,   87,   79,   37,   86, 5629, 5629,
 -      102,   85,  102, 5629, 5629, 5629,  145,  224,  186,    0,
 -      210,  150,  225,  137,  185, 5629,  193,  199,  198,  211,
 -      221,  239,  254,  263,  275,  288,  282,  297,  303,  357,
 -      337,  345,  365,  378,  385,    0,  386,  400,  418,  423,
 -      427, 5629,    0, 5629,  141,  192,  136,  164,  161,  204,
 -      207,  166, 5629,  187,  161, 5629,  183, 5629,  105,  443,
 -      451,  140,  458,  480,  476,  467,  522,  529,  535,  541,
--
-       978,  276,  942,  976,  957,  954,  954,  948,  951,  941,
-       934,  933,  208,  967,  933,  934,  942,  931,  296,  192,
-       942,  943,  941,  925,  929,  925,  934,  927,  921,    0,
-       919,  924,  929,  922, 1022,    0,  917,  924,  952, 1022,
-       328,  928,  923,  922,  908,  942,  923,  904,  911,  916,
-       905,  915,  917,  912,  905,  906,  904,  895,  897,  910,
-      1022,  897,  904,  907,  890,  923,  889,  897,  920,  897,
-       892,  885,  898,  881,  882,  879,  884,  888,  884,  888,
-       882,  876,  888,  883,  882,  866,  880,  874,  880,  869,
-       863,  875,  874,  862,  868,  859,  870, 1022, 1022,  855,
 -      547,  557,  570,  580,  563,  591,  603,  619,  625,  631,
 -      637,  644,  654,  660,  666,  673,  682,  694,  706,  715,
 -      722,  728,  735,  743,  793,  750,  764,  778,  784,  807,
 -      817,  832,  841,  850,  860,    0,  169,  212,  179,  234,
 -      271,  219,   87, 5629,    0,  866,  884,  116, 5629,  913,
 -      874,  899,  939,  954,  960,  967,  975,  982,  993, 1003,
 -     1010, 1018, 1029, 1038, 1044, 1054, 1062, 1072, 1080, 5629,
 -     1088, 1095, 1101, 1108, 1137, 1117, 1123, 1143, 1156, 1171,
 -     1177, 1184, 1191, 1197, 1205, 1220, 1230, 1239, 1248, 1258,
 -     1267, 1273, 1287, 1293, 1302, 1309, 1322, 1328, 1335, 1342,
--
-         0,  290,  864,  349,  849,  858,  892,  853,  862,  889,
-       859,  856,  857,  282,  885,  847,  845,  841,  843,  841,
-       362,  852,  852,  837,  838,  849,  847,  842,  849,  844,
-       831,  869,  832,  826,  832,  822,  828,  832,  265,  274,
-       836,  825,  825,  821,  813,  814,  818,  828,  816,  826,
-       825,  824,  850,  849,  848,  847,  820,  814,  818,    0,
-       843,  842,  815,  805,  394,  839,  798, 1022,  801,  800,
-      1022,  802,  799,  810,  806,  795, 1022,  791,  792,  802,
-       800,  821, 1022,  787,  801,  818,  822,  795,  789,  791,
-       792,  812,  781,  777,  776,  777, 1022,  777,  771,  783,
 -     1357, 1368, 1376, 1385, 1397,  286, 5629, 5629,  310, 5629,
 -     5629,   58,    0, 1409, 1420, 1451, 1435, 1449, 1477, 1493,
 -     1499, 1505, 1512, 1518, 1527, 1546, 1533, 1540, 1562, 1569,
 -     1575, 1581, 1595, 1609, 1615, 1628, 1634, 1649, 1656, 1662,
 -     1668, 1674, 1691, 1697, 1707, 1714, 1720, 1726, 1732, 1743,
 -     1760, 1769, 1777, 1788, 1794, 1802, 1816, 1822, 1828, 1837,
 -     1856, 1862, 1870, 1879, 1885, 1891, 1898, 1914, 1920, 1927,
 -     5629, 5629,   65,    0, 1933, 1939, 1948, 1955, 1990, 1961,
 -     1967, 5629, 1974, 1983, 5629, 1989, 2035, 2041, 2047, 2054,
 -     5629, 2060, 2069, 2088, 2095, 2103, 5629, 2114, 2123, 2131,
--
-       773,  772,  768, 1022,  806,  767,  760,  798,  767,  775,
-       774,  313,  794,  756,  759,  765,  755,  794,  753, 1022,
-      1022, 1022, 1022,  787,  755,  763,    0, 1022, 1022,  754,
-       759, 1022,  782,  753,  747,  757,  756,  742,  755,  770,
-       738,  740,  750,  750,  742,  747,  739,  746, 1022,  733,
-       742,  746,  730,  741,  726,  720,  725,  722,  757,  311,
-       721,  722,  726,  718, 1022,  719,  334,  731,  722,  749,
-       748, 1022,  713,  711,  727,  744,  708,  742, 1022,  312,
-       713,  710, 1022,  705,  743,  717,  736,  706,  697,  733,
-       710,  701,  730,  701,  702,  706,  726,  699,  690,  701,
 -     2137, 2143, 2151, 2160, 2166, 2177, 2184, 2201, 2210, 2217,
 -     5629, 2223, 2234, 2243, 2252, 2262, 2271, 5629, 2287, 2296,
 -     2304, 2311, 2324, 2330, 2337, 2347, 2353, 2365, 2372, 2381,
 -     2388, 2394, 2400, 5629, 5629, 5629, 5629, 2406, 2428,   54,
 -        0, 5629, 5629, 2434, 2441, 5629, 2448, 2454, 2462, 2469,
 -     2483, 2491, 2502, 2509, 2516, 2525, 2531, 2544, 2551, 2559,
 -     2572, 2579, 5629, 2587, 2600, 2607, 2620, 2626, 2633, 2643,
 -     2654, 2661, 2667, 2678, 2687, 2696, 2702, 2716, 5629, 2722,
 -     2730, 2750, 2756, 2765, 2776, 5629, 2789, 2798, 2804, 2810,
 -     2817, 2823, 5629, 2843, 2851, 2859, 5629, 2865, 2871, 2877,
--
-       704,  699,  694,  699,  696,  699,  694,  720,  719,  680,
-       691, 1022,  680,  688,  688,  674,  712,  684, 1022,  677,
-       670,  672,  662,  666,  665,  663,  672,  662,  670,  655,
-       306, 1022,  699,  667,  697,  696, 1022,  662,  655,  670,
-       665,  654,  664,  650,  651,  664,  647,  680,  651,  659,
-       655,  681,  640,  640,  651,  650,  637,  635,  636, 1022,
-      1022,  648,  355,  635,  633,  670,  669, 1022,  642,  640,
-       666,  631,  664,  632,  617,  624,  626,  628,  632,  657,
-       633,  610, 1022,  626, 1022, 1022,  630,  616,  611,  617,
-       611,  643,  647,  610,  605,  617,  606,  615,  603,  602,
 -     2885, 2899, 2910, 2918, 2924, 2933, 2939, 2946, 2952, 2967,
 -     2987, 2974, 2981, 3002, 3010, 3020, 3026, 3035, 3046, 3055,
 -     3061, 3074, 3081, 3094, 3102, 5629, 3109, 3115, 3123, 3130,
 -     3137, 3148, 5629, 3158, 3165, 3172, 3183, 3191, 3200, 3206,
 -     3212, 3224, 3234, 3246, 3260, 5629, 3267, 3279, 3285, 3293,
 -     5629, 3300, 3308, 3314, 3326, 3334, 3342, 3350, 3362, 3368,
 -     3376, 3385, 3391, 3397, 3405, 3413, 3419, 3430, 3438, 3447,
 -     3453, 3459, 3467, 5629, 5629, 3473, 3487, 3493, 3501, 3507,
 -     3513, 5629, 3527, 3535, 3547, 3553, 3561, 3568, 3575, 3581,
 -     3587, 3596, 3603, 3615, 3621, 3643, 5629, 3649, 5629, 5629,
--
-      1022,  616,  599,  599,  342,  597,  612,  592,  606,  592,
-       603,  590,  590, 1022, 1022,  623,  592, 1022,  592, 1022,
-       591,  587,  586,  595,  585,  620, 1022,  585,  581,  590,
-       577,  590,  614,  613,  576,  578, 1022,  572,  582,  603,
-       569,  583,  582,  562,  579,  602,  601, 1022,  569,  363,
-       360,  575,  575,  558,  573,  595,  563,  593,  559,  591,
-       559,  562,  561,  554,  548,  550, 1022,  557,  556,  542,
-       542,  548, 1022, 1022,  555,  551,  537,  576,  544,  547,
-       534,  534,  548,  547, 1022, 1022,  543, 1022,  543, 1022,
-       528,  543,  532,  564,  563, 1022,  526, 1022,  530, 1022,
 -     3658, 3664, 3671, 3677, 3683, 3697, 3716, 3725, 3734, 3740,
 -     3749, 3758, 3769, 3775, 5629, 3782, 3791, 3803, 3811, 3826,
 -     3832, 3839, 3846, 3854, 3868, 3879, 3887, 5629, 5629, 3894,
 -     3912, 5629, 3920, 5629, 3928, 3935, 3941, 3948, 3956, 3963,
 -     5629, 3970, 3976, 3991, 4005, 4012, 4019, 4026, 4033, 4040,
 -     5629, 4052, 4059, 4068, 4074, 4087, 4094, 4103, 4109, 4115,
 -     4131, 5629, 4137, 4149, 4160, 4166, 4172, 4182, 4188, 4195,
 -     4208, 4216, 4224, 4230, 4236, 4242, 4252, 4258, 4265, 4275,
 -     5629, 4287, 4293, 4299, 4308, 4316, 5629, 5629, 4333, 4341,
 -     4352, 4361, 4370, 4376, 4385, 4394, 4405, 4418, 5629, 5629,
--
-       520,  521,  519,  526,  556,  291,  555,  554,  522,  369,
-       525,  528,  515,  549, 1022,  522,  519,  519,  514,  504,
-       504,  542,  505,  540,  500,  538, 1022, 1022,  502,  508,
-       535,  534,  533,  505, 1022,  497,  530, 1022, 1022,  495,
-      1022,  489,  487,  486,  525, 1022,  524,  492,  483,  480,
-       468,  453, 1022,  443, 1022,  444, 1022,   62,   76, 1022,
-      1022, 1022,  167,  168, 1022,  254,  314,  332,  309, 1022,
-      1022,  304,  344,  311,  334,  371,  351,  380,  383,  344,
-       380,  360,  388, 1022, 1022,  353,  390,  354,  392,  358,
-      1022,  363, 1022, 1022,  367,  363,  373, 1022,  370, 1022,
 -     4427, 5629, 4441, 5629, 4447, 4455, 4461, 4467, 4475, 5629,
 -     4481, 5629, 4495, 5629, 4503, 4509, 4515, 4521, 4531, 4544,
 -     4556, 4567, 4573, 4579, 4585, 4591, 4601, 4607, 5629, 4620,
 -     4627, 4636, 4642, 4649, 4655, 4661, 4671, 4677, 4689, 4695,
 -     5629, 5629, 4710, 4723, 4729, 4736, 4743, 4749, 5629, 4764,
 -     4771, 5629, 5629, 4777, 5629, 4784, 4790, 4797, 4806, 5629,
 -     4812, 4819, 4825, 4831, 4845, 4853, 5629, 4859, 5629, 4866,
 -     5629, 4878, 4894, 5629, 5629, 5629, 4902, 4911, 5629, 4917,
 -     4923, 4930, 4936, 5629, 5629, 4945, 4964, 4952, 4970, 4980,
 -     4987, 4993, 5004, 5015, 5021, 5028, 5037, 5629, 5629, 5043,
--
-       373,  369, 1022,  403,  383,  379,  377,  415,  411,  396,
-       388,  394,  426,  400,  388, 1022,  392,  395,  406,  406,
-      1022,  433,  403,  408,  436,  410,  411, 1022,  403,  402,
-      1022,  402,  407,  408,  413,  406,  406,  408,  412,  418,
-       419,  451,  426,  418,  426, 1022,  455,  427,  426, 1022,
-       458,  432, 1022,  422,  422,  462, 1022, 1022,  468,  475,
-       482,  489,  496,  503,  507,  512,  514,  516,  518,  520
 -     5049, 5056, 5063, 5071, 5629, 5077, 5629, 5629, 5084, 5092,
 -     5099, 5629, 5110, 5629, 5121, 5128, 5629, 5144, 5150, 5162,
 -     5168, 5179, 5187, 5201, 5213, 5220, 5226, 5234, 5242, 5629,
 -     5248, 5254, 5267, 5276, 5629, 5283, 5290, 5305, 5311, 5318,
 -     5324, 5629, 5330, 5340, 5629, 5347, 5353, 5359, 5365, 5375,
 -     5381, 5387, 5409, 5415, 5422, 5429, 5435, 5443, 5451, 5629,
 -     5469, 5476, 5484, 5629, 5492, 5498, 5629, 5504, 5510, 5518,
 -     5629, 5629, 5562, 5569, 5576, 5583, 5590, 5597, 5604, 5608,
 -     5613, 5615, 5617, 5619, 5621
--    } ;
--
- static yyconst flex_int16_t yy_def[771] =
 -static yyconst flex_int16_t yy_def[786] =
--    {   0,
-       758,    1,  759,  759,    1,    5,    5,    5,    5,    5,
-       758,  758,  758,  758,  758,  760,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  761,  758,  758,  758,
-       762,   15,  758,   42,   42,  763,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,  760,  758,  758,  758,  758,  758,  758,  764,
-       758,  758,  758,  758,  758,  758,  758,  758,  761,  758,
-       762,  758,  765,   42,   42,  766,   42,  763,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
 -      772,    1,  773,  773,    1,    5,    5,    5,    5,    5,
 -      772,  772,  772,  772,  774,  775,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  776,
 -      772,  772,  772,  777,  774,  772,  774,  774,  778,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  775,  772,  772,  772,  772,
 -      772,  772,  779,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  776,  772,  777,  772,  780,  774,
 -      774,  781,  774,  778,  774,  774,  774,  774,  774,  774,
--
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,  764,
-       758,  758,  758,  758,  758,  767,   42,   42,  766,  758,
-       763,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-       758,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,  758,  758,  758,  758,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  779,  772,  772,  772,  772,
 -      772,  772,  772,  772,  782,  774,  774,  781,  772,  778,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  772,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
--
-       768,   42,   42,  763,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,  758,  769,
-        42,   42,   42,   42,  763,   42,   42,  758,   42,   42,
-       758,   42,   42,   42,   42,   42,  758,   42,   42,   42,
-        42,   42,  758,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,  758,   42,   42,   42,
 -      774,  774,  774,  774,  774,  772,  772,  772,  772,  772,
 -      772,  772,  783,  774,  774,  778,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      772,  772,  772,  784,  774,  774,  774,  774,  778,  774,
 -      774,  772,  774,  774,  772,  774,  774,  774,  774,  774,
 -      772,  774,  774,  774,  774,  774,  772,  774,  774,  774,
--
-        42,   42,   42,  758,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,  758,
-       758,  758,  758,   42,   42,  758,  770,  758,  758,   42,
-        42,  758,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,  758,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,  758,   42,   42,   42,   42,   42,
-        42,  758,   42,   42,   42,   42,   42,   42,  758,   42,
-        42,   42,  758,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      772,  774,  774,  774,  774,  774,  774,  772,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  772,  772,  772,  772,  774,  774,  772,
 -      785,  772,  772,  774,  774,  772,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  772,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  772,  774,
 -      774,  774,  774,  774,  774,  772,  774,  774,  774,  774,
 -      774,  774,  772,  774,  774,  774,  772,  774,  774,  774,
--
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,  758,   42,   42,   42,   42,   42,   42,  758,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,  758,   42,   42,   42,   42,  758,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,  758,
-       758,   42,   42,   42,   42,   42,   42,  758,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,  758,   42,  758,  758,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  772,  774,  774,  774,  774,
 -      774,  774,  772,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  772,  774,  774,  774,  774,
 -      772,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  772,  772,  774,  774,  774,  774,  774,
 -      774,  772,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  772,  774,  772,  772,
--
-       758,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,  758,  758,   42,   42,  758,   42,  758,
-        42,   42,   42,   42,   42,   42,  758,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,  758,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,  758,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,  758,   42,   42,   42,
-        42,   42,  758,  758,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,  758,  758,   42,  758,   42,  758,
-        42,   42,   42,   42,   42,  758,   42,  758,   42,  758,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  772,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  772,  772,  774,
 -      774,  772,  774,  772,  774,  774,  774,  774,  774,  774,
 -      772,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      772,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  772,  774,  774,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      772,  774,  774,  774,  774,  774,  772,  772,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  772,  772,
--
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,  758,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,  758,  758,   42,   42,
-        42,   42,   42,   42,  758,   42,   42,  758,  758,   42,
-       758,   42,   42,   42,   42,  758,   42,   42,   42,   42,
-        42,   42,  758,   42,  758,   42,  758,   42,   42,  758,
-       758,  758,   42,   42,  758,   42,   42,   42,   42,  758,
-       758,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,  758,  758,   42,   42,   42,   42,   42,
-       758,   42,  758,  758,   42,   42,   42,  758,   42,  758,
 -      774,  772,  774,  772,  774,  774,  774,  774,  774,  772,
 -      774,  772,  774,  772,  774,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  772,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  774,
 -      772,  772,  774,  774,  774,  774,  774,  774,  772,  774,
 -      774,  772,  772,  774,  772,  774,  774,  774,  774,  772,
 -      774,  774,  774,  774,  774,  774,  772,  774,  772,  774,
 -      772,  774,  774,  772,  772,  772,  774,  774,  772,  774,
 -      774,  774,  774,  772,  772,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  772,  772,  774,
--
-        42,   42,  758,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,  758,   42,   42,   42,   42,
-       758,   42,   42,   42,   42,   42,   42,  758,   42,   42,
-       758,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   42,   42,  758,   42,   42,   42,  758,
-        42,   42,  758,   42,   42,   42,  758,    0,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758
 -      774,  774,  774,  774,  772,  774,  772,  772,  774,  774,
 -      774,  772,  774,  772,  774,  774,  772,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  772,
 -      774,  774,  774,  774,  772,  774,  774,  774,  774,  774,
 -      774,  772,  774,  774,  772,  774,  774,  774,  774,  774,
 -      774,  774,  774,  774,  774,  774,  774,  774,  774,  772,
 -      774,  774,  774,  772,  774,  774,  772,  774,  774,  774,
 -      772,    0,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772
--    } ;
--
- static yyconst flex_uint16_t yy_nxt[1076] =
 -static yyconst flex_uint16_t yy_nxt[5690] =
--    {   0,
--       12,   13,   14,   13,   12,   15,   16,   12,   17,   18,
--       19,   20,   21,   22,   22,   22,   23,   24,   12,   12,
-        12,   12,   25,   12,   26,   12,   27,   12,   12,   12,
-        12,   12,   25,   28,   12,   12,   12,   12,   12,   12,
-        29,   12,   12,   12,   12,   30,   12,   12,   12,   12,
-        12,   31,   32,   34,   14,   34,   34,   14,   34,   35,
-        38,   37,   35,   12,   12,   37,   12,   12,   12,   12,
-        12,   12,   12,   12,   12,   12,   38,   12,   69,   39,
-        12,   39,   12,   70,   12,  111,   68,   68,   68,  112,
-        12,   12,   12,   12,   36,   66,   12,   39,   12,   39,
 -       12,   12,   12,   25,   26,   12,   27,   12,   12,   28,
 -       12,   29,   12,   30,   12,   12,   12,   12,   12,   25,
 -       31,   12,   12,   12,   12,   12,   12,   32,   12,   12,
 -       12,   12,   33,   12,   12,   12,   12,   12,   34,   35,
 -       37,   14,   37,   37,   14,   37,   38,   78,   40,   38,
 -       12,   12,   40,   12,   12,   12,   12,   12,   12,   12,
 -       12,   12,   12,   41,   42,   41,   42,   72,   12,   12,
 -       78,   12,   73,  397,   12,   75,   12,   75,   12,   77,
--
-        39,   90,   39,   12,   91,   66,  679,   92,  680,   12,
-        12,   41,   41,   41,   42,   42,   43,   42,   42,   42,
-        42,   42,   42,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   44,   42,   45,   42,   46,   42,   42,   47,
-        42,   48,   49,   50,   42,   42,   51,   52,   42,   53,
-        54,   55,   56,   57,   58,   59,   60,   61,   62,   42,
-        42,   42,   42,   42,   64,  155,   65,   65,   65,   64,
-        97,   67,   67,   67,   82,   66,   72,  156,   72,   98,
-        66,   73,   73,   73,   64,   66,   67,   67,   67,   93,
-        66,  102,   82,   94,   83,   66,   95,   99,  681,  118,
 -       76,   76,   76,  340,   12,   12,   12,   12,   39,   12,
 -       12,  273,   12,   79,   77,   78,   67,   12,   68,   68,
 -       68,  149,   77,   12,   12,   44,   44,   44,   69,   79,
 -       46,   67,  212,   70,   70,   70,   79,   80,   81,   71,
 -       71,   71,   88,   69,   69,  149,   42,   47,   42,   69,
 -       48,   42,   82,   42,   76,   76,   76,   49,  145,   69,
 -       50,  137,   51,   52,   53,   69,  144,   54,   55,   89,
 -       56,   57,   58,   59,   60,   61,   62,   63,   64,   65,
 -       67,  137,   70,   70,   70,   44,   44,   44,   88,  138,
 -       46,  139,   69,   44,   44,   44,  139,  206,   46,   44,
--
-       103,  100,  104,  119,  101,   66,   42,   96,   42,  682,
-       105,  106,   83,   42,  107,   42,   42,   42,  128,  108,
-        42,   42,  129,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   87,  113,  186,  120,  114,  115,  187,
-        42,   73,   73,   73,  124,  121,  122,  116,  125,  117,
-       123,  173,  174,   42,   73,   73,   73,   42,   68,   68,
-        68,   42,  126,   68,   68,   68,  144,   66,   42,  153,
-       304,   42,   66,   42,   88,  145,   64,   66,   65,   65,
-        65,  161,   66,   72,  154,   72,  683,   66,   73,   73,
-        73,   64,  275,   67,   67,   67,  276,   66,  148,  149,
 -       44,   44,  208,   93,   46,   76,   76,   76,   69,  138,
 -       45,   44,   44,   44,  139,   89,   46,   49,  208,  142,
 -      206,   44,   44,   44,  143,   49,   46,   43,   86,  137,
 -       45,   49,  138,   84,   45,   90,   83,  207,   45,   44,
 -       44,   44,  208,   49,   46,   45,   74,   91,   45,  140,
 -       45,   94,  141,   49,   44,   44,   44,  207,  211,   46,
 -       43,   95,  206,   44,   44,   44,   96,  772,   46,   97,
 -      772,   49,   98,  772,   99,   44,   44,   44,  100,  772,
 -       46,  101,   44,   44,   44,  209,   49,   46,   44,   44,
 -       44,  772,  102,   46,  772,   49,  207,   44,   44,   44,
--
-       157,  636,   66,  158,  261,  262,  306,  150,  162,  305,
-       307,  263,   66,  141,  141,  141,  412,  432,  372,  684,
-       141,  141,  141,  373,  180,  181,  182,  433,  141,  141,
-       141,  141,  141,  141,  183,  637,  184,  685,  413,  419,
-       185,  204,  204,  204,  420,  686,  481,  548,  204,  204,
-       204,  482,  549,  687,  688,  689,  204,  204,  204,  204,
-       204,  204,  265,  265,  265,  590,  421,  283,  588,  265,
-       265,  265,  284,  589,  641,  690,  691,  265,  265,  265,
-       265,  265,  265,  510,  692,  693,  550,  511,  694,  695,
-       696,  697,  591,  698,  699,  700,  702,  703,  704,  705,
 -      772,  103,   46,   44,   44,   44,  772,   49,   46,  271,
 -      104,  105,  772,  108,   49,  106,  210,  115,  107,  772,
 -       49,  772,  109,  772,  110,  271,  772,  111,  112,   49,
 -      772,  113,  116,  271,  772,   49,  114,   44,   44,   44,
 -      772,  772,   46,  772,  772,   44,   44,   44,  772,  272,
 -       46,  772,  117,  772,  772,  772,  118,   44,   44,   44,
 -      772,  772,   46,  772,  772,   44,   44,   44,  772,   49,
 -       46,  772,  124,  772,  772,  772,  125,   49,   44,   44,
 -       44,  772,  772,   46,  126,   44,   44,   44,  772,   49,
 -       46,  772,  119,  127,  128,  120,  121,   49,  129,   71,
--
-       701,  642,  285,  706,  707,  708,  286,   42,   42,   42,
-       709,  710,  711,  712,   42,   42,   42,  713,  714,  715,
-       716,  717,   42,   42,   42,   42,   42,   42,  718,  719,
-       720,  721,  722,  723,  724,  725,  726,  727,  728,  729,
-       730,  731,  732,  733,  734,  735,  736,  737,  738,  739,
-       740,  741,  742,  743,  744,  745,  746,  747,  748,  749,
-       750,  751,  752,  753,  754,  755,  756,  757,   33,   33,
-        33,   33,   33,   33,   33,   63,  678,   63,   63,   63,
-        63,   63,   79,  677,   79,  676,   79,   79,   79,   81,
-        81,   81,   81,   81,   81,   81,   86,   86,   86,   86,
 -       71,   71,  772,  772,  130,  122,  772,  123,  131,   69,
 -       49,   67,  772,   68,   68,   68,  772,   49,  772,  772,
 -      134,  772,  132,   69,  135,   69,   75,  772,   75,  133,
 -      772,   76,   76,   76,   67,  772,   70,   70,   70,   69,
 -       71,   71,   71,   44,   44,   44,   69,  772,   46,  772,
 -       69,   44,   44,   44,  772,  772,   46,  772,   44,   44,
 -       44,  772,   69,   46,  772,  772,   69,   44,   44,   44,
 -      772,  772,   46,  772,  772,   49,   44,   44,   44,  772,
 -      146,   46,  772,   49,  772,  772,  772,  772,  772,  772,
 -       49,  772,  147,  150,  150,  150,  772,  772,  772,   49,
--
-        86,   86,   86,  130,  675,  130,  130,  130,  130,  130,
-        81,   81,  674,   81,  139,  139,  139,  139,  139,  201,
-       201,  260,  260,  327,  327,   81,   81,  673,  672,  671,
-       670,  669,  668,  667,  666,  665,  664,  663,  662,  661,
-       660,  659,  658,  657,  656,  655,  654,  653,  652,  651,
-       650,  649,  648,  647,  646,  645,  644,  643,  640,  639,
-       638,  635,  634,  633,  632,  631,  630,  629,  628,  627,
-       626,  625,  624,  623,  622,  621,  620,  619,  618,  617,
-       616,  615,  614,  613,  612,  611,  610,  609,  608,  607,
-       606,  605,  604,  603,  602,  601,  600,  599,  598,  597,
 -      150,  150,  150,  150,  150,  772,  772,  772,   49,  772,
 -      152,  772,  772,  772,  772,  150,  150,  150,  150,  150,
 -      150,  772,   44,   44,   44,  772,  151,   46,  772,   44,
 -       44,   44,  772,  772,   46,   44,   44,   44,  772,  772,
 -       46,   44,   44,   44,  772,  772,   46,   44,   44,   44,
 -      772,  772,   46,  772,   49,  772,  772,   44,   44,   44,
 -      153,   49,   46,   44,   44,   44,  772,   49,   46,  154,
 -       44,   44,   44,   49,  772,   46,  772,  157,  158,   49,
 -       44,   44,   44,  155,  160,   46,  159,  156,  772,   49,
 -      772,   44,   44,   44,  772,   49,   46,  772,  772,  772,
--
-       596,  595,  594,  593,  592,  587,  586,  585,  584,  583,
-       582,  581,  580,  579,  578,  577,  576,  575,  574,  573,
-       572,  571,  570,  569,  568,  567,  566,  565,  564,  563,
-       562,  561,  560,  559,  558,  557,  556,  555,  554,  553,
-       552,  551,  547,  546,  545,  544,  543,  542,  541,  540,
-       539,  538,  537,  536,  535,  534,  533,  532,  531,  530,
-       529,  528,  527,  526,  525,  524,  523,  522,  521,  520,
-       519,  518,  517,  516,  515,  514,  513,  512,  509,  508,
-       507,  506,  505,  504,  503,  502,  501,  500,  499,  498,
-       497,  496,  495,  494,  493,  492,  491,  490,  489,  488,
 -      161,  772,   49,   44,   44,   44,  772,  162,   46,  772,
 -      772,  166,   49,  169,  167,  772,  772,  164,  772,   44,
 -       44,   44,  163,   49,  170,   44,   44,   44,  772,  165,
 -       46,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      772,  173,   46,  772,   44,   44,   44,  772,  168,   46,
 -      772,   49,  772,  772,   44,   44,   44,   49,  171,   46,
 -       44,   44,   44,   49,  772,   46,   44,   44,   44,   49,
 -      772,   46,  174,   44,   44,   44,   49,  172,   46,  772,
 -      772,  175,   44,   44,   44,  772,   49,   46,  772,  772,
 -      176,  772,   49,  772,   44,   44,   44,  772,   49,   46,
--
-       487,  486,  485,  484,  483,  480,  479,  478,  477,  476,
-       475,  474,  473,  472,  471,  470,  469,  468,  467,  466,
-       465,  464,  463,  462,  461,  460,  459,  458,  457,  456,
-       455,  454,  453,  452,  451,  450,  449,  448,  447,  446,
-       445,  444,  443,  442,  441,  440,  439,  438,  437,  436,
-       435,  434,  431,  430,  429,  428,  427,  426,  425,  424,
-       423,  422,  418,  417,  416,  415,  414,  411,  410,  409,
-       408,  407,  406,  405,  404,  403,  402,  401,  400,  399,
-       398,  397,  396,  395,  394,  393,  392,  391,  390,  389,
-       388,  387,  386,  385,  384,  383,  382,  381,  380,  379,
 -      772,  177,  772,  178,  772,   49,   44,   44,   44,  772,
 -      772,   46,  772,  772,   49,   44,   44,   44,  772,  179,
 -       46,  772,   44,   44,   44,  184,   49,   46,   44,   44,
 -       44,  772,  772,   46,  180,   44,   44,   44,   49,  772,
 -       46,  772,  772,   44,   44,   44,  181,   49,   46,  772,
 -       44,   44,   44,  772,   49,   46,  182,  183,  772,  772,
 -       49,  772,  772,  772,   44,   44,   44,   49,  772,   46,
 -      772,  772,  185,  772,  187,   49,  186,  772,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,  772,   46,
 -      772,  772,  188,   44,   44,   44,   49,  772,   46,  772,
--
-       378,  377,  376,  375,  374,  371,  370,  369,  368,  367,
-       366,  365,  364,  363,  362,  361,  360,  359,  358,  357,
-       356,  355,  354,  353,  352,  351,  350,  349,  348,  347,
-       346,  345,  344,  343,  342,  341,  340,  339,  338,  337,
-       336,  335,  334,  333,  332,  331,  330,  329,  328,  326,
-       325,  324,  323,  322,  321,  320,  319,  318,  317,  316,
-       315,  314,  313,  312,  311,  310,  309,  308,  303,  302,
-       301,  300,  299,  298,  297,  296,  295,  294,  293,  292,
-       291,  290,  289,  288,  287,  282,  281,  280,  279,  278,
-       277,  274,  273,  272,  271,  270,  269,  268,  267,  266,
 -      195,  197,  772,  772,  196,  772,  772,   44,   44,   44,
 -       49,  772,   46,  198,  772,  772,   49,   44,   44,   44,
 -      199,  772,   46,  772,  772,   49,  772,  772,  189,  190,
 -      191,  772,   44,   44,   44,  772,  772,   46,  192,   49,
 -      193,   44,   44,   44,  194,  772,   46,  772,  772,   49,
 -       44,   44,   44,  772,  772,   46,  772,  772,  200,  772,
 -       44,   44,   44,  201,   49,   46,   44,   44,   44,  772,
 -      772,   46,  772,   49,   44,   44,   44,  772,  772,   46,
 -      203,  202,   49,  772,   44,   44,   44,  772,  772,   46,
 -      772,  772,   49,  772,  772,  204,  772,  772,   49,   44,
--
-       264,  259,  199,  258,  257,  256,  255,  254,  253,  252,
-       251,  250,  249,  248,  247,  246,  245,  244,  243,  242,
-       241,  240,  239,  238,  237,  236,  235,  234,  233,  232,
-       231,  230,  229,  228,  227,  226,  225,  224,  223,  222,
-       221,  220,  219,  218,  217,  216,  215,  214,  213,  212,
-       211,  210,  209,  208,  207,  206,  205,  140,  203,  202,
-       200,  199,  198,  197,  196,  195,  194,  193,  192,  191,
-       190,  189,  188,  179,  178,  177,  176,  175,  172,  171,
-       170,  169,  168,  167,  166,  165,  164,  163,  160,  159,
-       152,  151,  147,  146,  143,  142,  140,  138,  137,  136,
 -       44,   44,  772,  772,   46,  772,   49,  772,  772,  217,
 -      205,  772,  772,  772,  772,  214,   49,  772,  772,  772,
 -      772,  772,  772,  772,  772,  215,  216,  216,  216,  772,
 -      772,   49,  772,  216,  216,  216,  216,  216,  218,   44,
 -       44,   44,  772,  772,   46,  772,  772,  772,  216,  216,
 -      216,  216,  216,  216,   44,   44,   44,  772,  772,   46,
 -       44,   44,   44,  772,  772,   46,  772,   44,   44,   44,
 -      221,   49,   46,  772,  772,   44,   44,   44,  219,  772,
 -       46,  772,   44,   44,   44,  772,   49,   46,  772,  772,
 -      772,  772,   49,   44,   44,   44,  772,  772,   46,   49,
--
-       135,  134,  133,  132,  131,  127,  110,  109,   89,   85,
-        84,   40,   80,   78,   77,   76,   75,   74,   71,   40,
-       758,   11,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758
 -      772,  772,  222,   44,   44,   44,  220,   49,   46,  772,
 -       44,   44,   44,  772,   49,   46,  772,  772,   44,   44,
 -       44,  772,  772,   46,  772,   49,  772,  224,  223,   44,
 -       44,   44,  225,  772,   46,   49,  772,  772,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,  227,   46,
 -       49,  772,  226,  228,   44,   44,   44,  772,  772,   46,
 -      772,   49,   44,   44,   44,  772,  772,   46,  229,  772,
 -       49,  772,   44,   44,   44,  772,   49,   46,  772,  772,
 -       44,   44,   44,  230,  772,   46,   49,  231,   44,   44,
 -       44,  772,  772,   46,   49,   44,   44,   44,  232,  772,
 -
 -       46,   44,   44,   44,   49,  772,   46,  772,   44,   44,
 -       44,  772,   49,   46,  233,  235,  772,   44,   44,   44,
 -       49,  234,   46,   44,   44,   44,  772,   49,   46,  772,
 -      772,  772,  772,   49,  237,  236,  238,   44,   44,   44,
 -       49,  772,   46,   44,   44,   44,  772,  240,   46,   49,
 -      772,  772,  772,  243,  772,   49,   44,   44,   44,  239,
 -      772,   46,  772,  772,  242,  772,  772,  241,  772,   49,
 -      772,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      772,  772,   46,  772,   44,   44,   44,  772,   49,   46,
 -      772,   44,   44,   44,  772,  244,   46,   44,   44,   44,
 -
 -      772,  772,   46,   49,  772,   44,   44,   44,  772,   49,
 -       46,  772,  772,  772,  245,  772,   49,  772,  772,  247,
 -       44,   44,   44,   49,  772,   46,  246,  772,  772,   49,
 -       44,   44,   44,  772,  772,   46,  772,   49,  772,   44,
 -       44,   44,  248,  772,   46,  772,  249,  772,   44,   44,
 -       44,  772,   49,   46,  772,  772,  250,  772,   44,   44,
 -       44,  772,   49,   46,  772,  251,  772,   44,   44,   44,
 -      252,   49,   46,   44,   44,   44,  772,  772,   46,  772,
 -       49,  772,  253,  772,  772,  772,  254,   44,   44,   44,
 -       49,  772,   46,   44,   44,   44,  772,  772,   46,   49,
 -
 -      772,  255,   44,   44,   44,   49,  772,   46,  257,   44,
 -       44,   44,  772,  772,   46,  256,  772,  772,  772,   49,
 -      772,  772,   44,   44,   44,   49,  258,   46,   44,   44,
 -       44,  772,  259,   46,   49,   44,   44,   44,  772,  772,
 -       46,   49,   44,   44,   44,  772,  772,   46,  261,  772,
 -      772,  772,  772,  772,   49,  772,  260,   44,   44,   44,
 -       49,  772,   46,  772,  772,  263,  262,   49,   44,   44,
 -       44,  772,  772,   46,   49,  772,   44,   44,   44,  772,
 -      772,   46,  264,  772,  772,   44,   44,   44,  772,   49,
 -       46,  772,  772,  772,  265,  772,  266,   44,   44,   44,
 -
 -       49,  772,   46,  772,  772,  772,  772,  267,   49,   44,
 -       44,   44,  772,  772,   46,  772,  772,   49,  772,  772,
 -       44,   44,   44,  275,  276,   46,  268,  772,  269,   49,
 -      772,  277,  772,  772,  772,   44,   44,   44,  772,  772,
 -       46,   49,  772,  772,  772,  772,  772,  772,  270,   44,
 -       44,   44,   49,  772,   46,  772,  772,  772,  772,  772,
 -      772,  772,  772,  278,  279,  279,  279,   49,  772,  772,
 -      772,  279,  279,  279,  279,  279,  772,   44,   44,   44,
 -      772,   49,  282,  772,  772,  772,  279,  279,  279,  279,
 -      279,  279,  280,   44,   44,   44,  281,  772,   46,   44,
 -
 -       44,   44,  772,  772,   46,   44,   44,   44,  772,   49,
 -      285,  772,   44,   44,   44,  772,  772,   46,   44,   44,
 -       44,  772,  772,   46,  772,   49,  772,   44,   44,   44,
 -      772,   49,   46,   44,   44,   44,  772,   49,  291,  284,
 -       44,   44,   44,  283,   49,   46,   44,   44,   44,  772,
 -       49,   46,  772,  286,  772,  772,  289,  772,  772,   49,
 -      290,  287,   44,   44,   44,   49,  772,   46,  288,   44,
 -       44,   44,   49,  772,   46,   44,   44,   44,   49,  772,
 -       46,   44,   44,   44,  772,  772,   46,  772,  772,  292,
 -      772,  772,  772,  772,   49,   44,   44,   44,  772,  772,
 -
 -      297,   49,  772,  772,  772,  298,  772,   49,  772,   44,
 -       44,   44,  293,   49,   46,   44,   44,   44,  772,  772,
 -       46,  772,  294,  772,  772,  295,  772,   49,   44,   44,
 -       44,  772,  296,   46,   44,   44,   44,  772,  772,   46,
 -      772,   49,  299,  772,  772,  772,  300,   49,  301,   44,
 -       44,   44,  772,  302,   46,  772,   44,   44,   44,  772,
 -       49,   46,   44,   44,   44,  772,   49,   46,   44,   44,
 -       44,  772,  772,   46,   44,   44,   44,  772,  772,   46,
 -      303,   49,  772,  772,  304,  772,  772,  305,   49,  772,
 -      772,   44,   44,   44,   49,  306,   46,   44,   44,   44,
 -
 -       49,  772,  311,  308,  772,  307,   49,   44,   44,   44,
 -      772,  772,   46,  309,   44,   44,   44,  772,  772,   46,
 -       44,   44,   44,   49,  772,   46,   44,   44,   44,   49,
 -      772,   46,   44,   44,   44,  772,  772,   46,  772,   49,
 -      772,  772,  310,   44,   44,   44,   49,  772,   46,  772,
 -      772,  772,   49,  772,  772,  312,  772,  772,   49,  772,
 -       44,   44,   44,  772,   49,  318,  314,  313,  772,   44,
 -       44,   44,  772,  772,   46,   49,  772,   44,   44,   44,
 -      316,  315,   46,  772,  772,  772,  317,  772,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,  772,   46,
 -
 -      772,   49,   44,   44,   44,  772,  772,   46,  320,   49,
 -      772,  319,  321,  772,  772,  322,   44,   44,   44,  772,
 -       49,   46,   44,   44,   44,  772,   49,   46,   44,   44,
 -       44,  772,  772,   46,   49,  772,  323,   44,   44,   44,
 -      772,  324,   46,  772,  772,  772,  772,  772,   49,  772,
 -      772,  772,  325,  772,   49,  772,   44,   44,   44,  772,
 -       49,   46,   44,   44,   44,  772,  772,   46,  772,   49,
 -       44,   44,   44,  326,  772,   46,  329,  327,  328,   44,
 -       44,   44,  772,  772,   46,   44,   44,   44,   49,  772,
 -      334,   44,   44,   44,   49,  772,  335,  772,   44,   44,
 -
 -       44,  331,   49,  336,  772,  772,  330,  772,  772,  332,
 -      772,   49,  772,  772,   44,   44,   44,   49,  333,  337,
 -       44,   44,   44,   49,  772,   46,  772,   44,   44,   44,
 -       49,  772,   46,   44,   44,   44,  772,  772,  342,   44,
 -       44,   44,  772,  772,  343,  772,   49,  772,   44,   44,
 -       44,  772,   49,   46,  772,   44,   44,   44,  338,   49,
 -       46,   44,   44,   44,  772,   49,  346,   44,   44,   44,
 -      339,   49,   46,  772,   44,   44,   44,  772,  772,   46,
 -       49,  772,  772,   44,   44,   44,  344,   49,   46,   44,
 -       44,   44,  772,   49,   46,  772,  772,  772,  772,   49,
 -
 -      772,  772,  345,   45,   45,   45,   49,  772,  772,  772,
 -       45,   45,   45,   45,   45,   49,  772,  772,  772,  347,
 -      772,   49,  348,  772,  772,   45,   45,   45,   45,   45,
 -       45,  349,  772,  772,  350,   44,   44,   44,  772,  772,
 -       46,   44,   44,   44,  772,  772,   46,   44,   44,   44,
 -      772,  772,   46,  772,   44,   44,   44,  772,  772,   46,
 -       44,   44,   44,  772,  772,   46,  772,   49,  772,   44,
 -       44,   44,  772,   49,   46,  772,  352,  772,  772,   49,
 -      772,  772,  351,  772,  772,  353,   49,  772,   44,   44,
 -       44,  772,   49,   46,  772,   44,   44,   44,  772,  772,
 -
 -       46,   49,  354,   44,   44,   44,  772,  772,   46,  772,
 -      772,  355,  772,  359,   44,   44,   44,  772,  356,   46,
 -       49,  772,  772,   44,   44,   44,  357,   49,   46,  772,
 -      772,   44,   44,   44,  358,   49,   46,   44,   44,   44,
 -      772,  362,  363,   44,   44,   44,   49,  772,   46,  772,
 -      772,   44,   44,   44,  772,   49,   46,  772,  361,  772,
 -       44,   44,   44,   49,  360,   46,   44,   44,   44,   49,
 -      772,   46,  772,  772,  772,   49,  772,   44,   44,   44,
 -      772,  364,   46,   49,   44,   44,   44,  368,  772,   46,
 -      772,  772,   49,  772,  365,  772,  772,  772,   49,  772,
 -
 -      366,   44,   44,   44,  367,  772,   46,  772,  772,   49,
 -       44,   44,   44,  772,  772,   46,   49,   44,   44,   44,
 -      772,  772,   46,   44,   44,   44,  772,  772,   46,  772,
 -      772,  369,  772,   49,   44,   44,   44,  772,  772,   46,
 -      772,  772,   49,   44,   44,   44,  772,  772,   46,   49,
 -      772,  370,   44,   44,   44,   49,  772,   46,  772,  772,
 -      371,  772,   44,   44,   44,  372,   49,   46,  772,  772,
 -      373,   44,   44,   44,  772,   49,   46,  772,  772,  772,
 -      772,  772,  375,  772,   49,  772,  374,   44,   44,   44,
 -      772,  772,  379,  772,   49,  772,   44,   44,   44,  772,
 -
 -      376,   46,  772,   49,   44,   44,   44,  772,  772,   46,
 -      377,   44,   44,   44,  772,  772,   46,  772,  772,   49,
 -      772,  382,  378,  772,   44,   44,   44,  772,   49,   46,
 -       44,   44,   44,  772,  772,   46,   49,   44,   44,   44,
 -      772,  772,   46,   49,  772,  772,  380,   44,   44,   44,
 -      772,  772,  386,   44,   44,   44,   49,  387,   46,  772,
 -      381,  772,   49,  388,  772,   44,   44,   44,  384,   49,
 -       46,  383,   44,   44,   44,  385,  772,   46,  772,   49,
 -      772,   44,   44,   44,  772,   49,   46,  772,   44,   44,
 -       44,  772,  772,   46,   44,   44,   44,   49,  772,  393,
 -
 -       44,   44,   44,  772,   49,   46,   44,   44,   44,  772,
 -      772,   46,  772,   49,  772,  772,  395,  772,  772,  389,
 -       49,  772,  390,  772,  391,  772,   49,  772,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,   49,   46,
 -      392,   44,   44,   44,  772,  772,   46,  772,   44,   44,
 -       44,  772,  394,   46,   44,   44,   44,  772,  400,   46,
 -       49,  772,   44,   44,   44,  772,   49,   46,  772,   44,
 -       44,   44,  772,   49,   46,  772,  396,  772,  772,  772,
 -       49,  398,  399,   44,   44,   44,   49,  772,   46,  772,
 -      772,   44,   44,   44,   49,  772,   46,  772,  772,  401,
 -
 -      772,   49,   44,   44,   44,  772,  772,   46,  403,   44,
 -       44,   44,  402,  772,   46,   49,   44,   44,   44,  772,
 -      772,   46,  404,   49,  407,   44,   44,   44,  772,  772,
 -       46,   44,   44,   44,   49,  772,   46,  772,  772,  772,
 -      406,   49,  772,  405,   44,   44,   44,  772,   49,   46,
 -      772,   44,   44,   44,  772,  772,   46,   49,  772,   44,
 -       44,   44,  772,   49,   46,  772,  772,  772,  772,  408,
 -      410,  772,   44,   44,   44,  409,   49,   46,  772,   44,
 -       44,   44,  411,   49,   46,  772,  772,   44,   44,   44,
 -      772,   49,   46,  772,  772,  772,  412,  772,  413,  772,
 -
 -       44,   44,   44,  772,   49,   46,  772,   44,   44,   44,
 -      772,   49,   46,  772,  772,  772,  772,  415,  414,   49,
 -       44,   44,   44,  772,  772,   46,   44,   44,   44,  772,
 -      772,   46,   49,   44,   44,   44,  772,  416,   46,   49,
 -      417,  772,  418,   44,   44,   44,  772,  772,   46,  772,
 -      772,  772,   49,  772,   44,   44,   44,  772,   49,   46,
 -      772,   44,   44,   44,  420,   49,   46,   44,   44,   44,
 -      419,  772,   46,  772,  772,   49,  772,  425,   44,   44,
 -       44,  772,  772,  426,  772,  421,   49,   44,   44,   44,
 -      772,  772,   46,   49,  772,  772,   44,   44,   44,   49,
 -
 -      422,   46,   44,   44,   44,  423,  772,   46,  772,  772,
 -       49,  772,  427,  772,  424,  772,   44,   44,   44,   49,
 -      772,   46,   44,   44,   44,  772,  772,   46,   49,  772,
 -       44,   44,   44,  772,   49,  433,  772,  772,  772,  428,
 -      434,  772,  772,  772,  772,  772,  429,  430,   49,  772,
 -       44,   44,   44,  772,   49,   46,   44,   44,   44,  772,
 -      772,   46,   49,  772,  772,   44,   44,   44,  431,  435,
 -       46,  772,  432,  772,  772,  438,   44,   44,   44,  772,
 -      772,   46,   49,  772,  772,  772,  439,  436,   49,   44,
 -       44,   44,  772,  772,   46,  772,  772,   49,   44,   44,
 -
 -       44,  437,  772,   46,   44,   44,   44,  772,   49,   46,
 -       44,   44,   44,  772,  772,   46,  772,   44,   44,   44,
 -      443,   49,   46,   44,   44,   44,  772,  772,   46,  772,
 -       49,  772,  772,  445,  772,  772,   49,  772,  772,  442,
 -      440,  772,   49,   44,   44,   44,  772,  772,  446,   49,
 -      441,   44,   44,   44,  772,   49,   46,  772,  447,   44,
 -       44,   44,  772,  772,   46,   44,   44,   44,  772,  444,
 -       46,   44,   44,   44,  772,   49,  451,   44,   44,   44,
 -      772,  772,   46,   49,  772,   44,   44,   44,  772,  772,
 -       46,   49,  772,  772,  772,  453,  448,   49,  772,   44,
 -
 -       44,   44,  772,   49,   46,  772,  449,  772,  772,   49,
 -       44,   44,   44,  772,  452,   46,  450,   49,   44,   44,
 -       44,  772,  772,   46,   44,   44,   44,  772,  456,   46,
 -      772,   49,  772,   44,   44,   44,  772,  772,   46,   44,
 -       44,   44,   49,  772,   46,  454,   44,   44,   44,  459,
 -       49,   46,   44,   44,   44,  772,   49,   46,  772,  772,
 -      772,  772,  772,  457,  455,   49,  772,   44,   44,   44,
 -      772,   49,   46,  772,   44,   44,   44,  772,   49,   46,
 -      458,   44,   44,   44,   49,  772,   46,   44,   44,   44,
 -      772,  460,   46,  772,  772,  461,  772,  463,  772,   49,
 -
 -      772,  772,   44,   44,   44,  462,   49,   46,  772,  772,
 -       44,   44,   44,   49,  772,   46,  772,  464,  772,   49,
 -       44,   44,   44,  772,  772,   46,   44,   44,   44,  772,
 -      772,   46,  465,  772,   49,   44,   44,   44,  772,  772,
 -       46,  466,   49,  772,  772,  467,   44,   44,   44,  772,
 -      772,   46,   49,  772,  772,   44,   44,   44,   49,  468,
 -       46,   44,   44,   44,  772,  772,   46,   49,  772,  469,
 -      772,  772,  470,  772,   44,   44,   44,  772,   49,  474,
 -      772,   44,   44,   44,  772,  471,  475,   49,  772,  772,
 -      472,  772,  772,   49,   44,   44,   44,  772,  772,   46,
 -
 -      473,  772,   44,   44,   44,  772,   49,   46,  772,   44,
 -       44,   44,  772,   49,   46,   44,   44,   44,  772,  772,
 -       46,  772,  772,   44,   44,   44,   49,  772,   46,  772,
 -       44,   44,   44,  772,   49,   46,  772,   44,   44,   44,
 -      477,   49,  482,  772,  476,  772,  772,   49,   44,   44,
 -       44,  772,  772,   46,  479,   49,  772,  478,   44,   44,
 -       44,  480,   49,   46,  772,   44,   44,   44,  772,   49,
 -       46,  772,   44,   44,   44,  772,  772,   46,  772,  772,
 -       49,  481,  772,   44,   44,   44,  772,  483,   46,  772,
 -       49,   44,   44,   44,  772,  772,   46,   49,  772,  772,
 -
 -       44,   44,   44,  484,   49,   46,   44,   44,   44,  772,
 -      772,   46,   44,   44,   44,   49,  485,   46,  772,  772,
 -      486,  772,  772,   49,   44,   44,   44,  772,  772,   46,
 -      772,  772,   49,  772,   44,   44,   44,  772,   49,   46,
 -      487,  772,  772,  488,   49,  772,   44,   44,   44,  772,
 -      772,   46,  489,  772,  772,  491,   49,  772,  772,  490,
 -       44,   44,   44,  772,  772,   46,   49,   44,   44,   44,
 -      772,  772,  497,  772,  772,  772,  492,  493,   49,   44,
 -       44,   44,  772,  772,   46,   44,   44,   44,  772,  772,
 -      499,  772,   49,   44,   44,   44,  772,  772,  500,   49,
 -
 -       44,   44,   44,  494,  772,   46,  772,  495,   44,   44,
 -       44,   49,  496,   46,   44,   44,   44,   49,  772,   46,
 -      772,  772,  498,  772,  772,   49,   44,   44,   44,  772,
 -      772,   46,   49,  772,   44,   44,   44,  772,  772,   46,
 -       49,  772,   44,   44,   44,  501,   49,   46,  772,  503,
 -       44,   44,   44,  772,  772,   46,  772,  772,   49,  502,
 -      772,  772,   44,   44,   44,  504,   49,   46,   44,   44,
 -       44,  772,  772,   46,   49,  772,   44,   44,   44,  772,
 -      506,   46,   49,  505,  772,   44,   44,   44,  772,  772,
 -       46,   44,   44,   44,   49,  511,   46,   44,   44,   44,
 -
 -       49,  507,   46,  509,  772,   44,   44,   44,   49,  772,
 -       46,  508,  772,   44,   44,   44,  772,   49,  515,   44,
 -       44,   44,  772,   49,   46,  772,  772,  510,  772,   49,
 -       44,   44,   44,  513,  772,   46,  512,   49,   44,   44,
 -       44,  772,  772,   46,  514,   49,  772,   44,   44,   44,
 -      772,   49,   46,   44,   44,   44,  772,  772,   46,   44,
 -       44,   44,   49,  772,   46,  772,  772,   44,   44,   44,
 -       49,  516,   46,   44,   44,   44,  772,  518,   46,   49,
 -      772,  517,  772,  772,  772,   49,  519,   44,   44,   44,
 -      772,   49,   46,   44,   44,   44,  772,  772,   46,   49,
 -
 -      772,   44,   44,   44,  520,   49,   46,   44,   44,   44,
 -      523,  521,  528,   44,   44,   44,  772,  522,  529,   49,
 -      772,  772,  524,  772,  772,   49,  525,   44,   44,   44,
 -      772,  772,   46,   49,  772,   44,   44,   44,  772,   49,
 -       46,  772,  526,  772,  772,   49,  772,   44,   44,   44,
 -      772,  527,  532,   44,   44,   44,  772,  772,   46,   49,
 -      772,   44,   44,   44,  772,  530,  534,   49,   44,   44,
 -       44,  772,  772,   46,  531,   44,   44,   44,  772,   49,
 -       46,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      772,  772,   46,   49,  772,  772,   44,   44,   44,  533,
 -
 -       49,   46,  772,   44,   44,   44,  772,   49,   46,  772,
 -      772,  535,  772,   49,  772,   44,   44,   44,  772,   49,
 -      541,   44,   44,   44,  772,  772,   46,  772,   49,  772,
 -      537,  772,  536,  538,  772,   49,  772,  772,  772,  539,
 -      772,  540,  772,   44,   44,   44,  772,   49,   46,   44,
 -       44,   44,  772,   49,   46,  772,  542,  772,   44,   44,
 -       44,  772,  772,   46,   44,   44,   44,  772,  772,   46,
 -      772,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      772,   49,   46,   44,   44,   44,  772,  772,   46,  544,
 -       49,  772,  772,  545,  772,  772,   49,   44,   44,   44,
 -
 -      543,  772,   46,   49,  772,  772,  772,  550,  772,   49,
 -      772,  772,  546,  772,  772,   49,   44,   44,   44,  772,
 -      772,  551,  548,  547,  772,   44,   44,   44,  772,   49,
 -       46,  772,  772,  549,   44,   44,   44,  772,  772,   46,
 -       44,   44,   44,  772,  772,   46,  772,  772,   49,   44,
 -       44,   44,  772,  772,   46,  772,  772,   49,   44,   44,
 -       44,  772,  772,   46,  772,  772,   49,  772,  772,   44,
 -       44,   44,   49,  552,   46,   44,   44,   44,  772,  554,
 -       46,   49,   44,   44,   44,  772,  553,   46,  772,  772,
 -       49,   44,   44,   44,  772,  772,   46,  556,  555,  772,
 -
 -      772,   49,  772,   44,   44,   44,  772,   49,   46,  772,
 -      772,   44,   44,   44,   49,  772,  562,  559,  772,  557,
 -      772,  563,  772,   49,  772,  558,   44,   44,   44,  772,
 -      772,   46,   44,   44,   44,   49,  772,   46,  772,   44,
 -       44,   44,  560,   49,   46,  772,   44,   44,   44,  772,
 -      772,   46,  772,  561,   44,   44,   44,  772,   49,   46,
 -      772,  772,  564,  772,   49,  772,  772,  566,   44,   44,
 -       44,   49,  772,   46,  772,  772,  772,  565,   49,   44,
 -       44,   44,  772,  772,   46,  568,   49,   44,   44,   44,
 -      772,  772,   46,  567,   44,   44,   44,  772,  772,   46,
 -
 -       49,  772,  772,  772,  573,  772,  569,  772,  570,  772,
 -      772,   49,   44,   44,   44,  772,  772,   46,  772,   49,
 -       44,   44,   44,  772,  772,   46,   49,  772,   44,   44,
 -       44,  571,  772,   46,  772,   44,   44,   44,  572,  772,
 -       46,   44,   44,   44,   49,  772,   46,  772,   44,   44,
 -       44,  772,   49,   46,  772,  772,   44,   44,   44,  574,
 -       49,   46,  772,   44,   44,   44,  575,   49,  581,  772,
 -       44,   44,   44,   49,  576,   46,   44,   44,   44,  772,
 -       49,   46,  772,  772,  577,  772,  772,  579,   49,  772,
 -      578,   44,   44,   44,  772,   49,   46,  772,  772,  772,
 -
 -      772,  772,   49,  772,  580,   44,   44,   44,   49,  772,
 -       46,  772,   44,   44,   44,  772,  582,   46,  772,   44,
 -       44,   44,  772,   49,  587,  583,   44,   44,   44,  772,
 -      584,  588,  772,   44,   44,   44,  772,   49,   46,  772,
 -       44,   44,   44,  772,   49,   46,  772,  772,  772,  586,
 -      772,   49,   44,   44,   44,  772,  585,   46,   49,   44,
 -       44,   44,  772,  772,   46,   49,  772,  772,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,  593,   46,
 -      772,  589,  772,  772,   49,  590,  772,   44,   44,   44,
 -      772,   49,   46,  772,   44,   44,   44,  772,  592,   46,
 -
 -       49,  772,  591,   44,   44,   44,   49,  772,   46,   44,
 -       44,   44,  772,  772,   46,   44,   44,   44,  772,   49,
 -      599,  772,  595,  772,  594,  772,   49,  772,  772,  596,
 -      772,   44,   44,   44,  772,   49,  600,   44,   44,   44,
 -      772,   49,   46,  772,  772,  598,  772,   49,  772,   44,
 -       44,   44,  772,  772,  602,  772,  772,  597,  772,  603,
 -       44,   44,   44,   49,  772,  604,   44,   44,   44,   49,
 -      772,   46,   44,   44,   44,  772,  772,   46,  772,  772,
 -      601,   49,   44,   44,   44,  772,  772,   46,   44,   44,
 -       44,  772,   49,   46,  772,   44,   44,   44,   49,  605,
 -
 -      610,  772,  606,  772,   49,  772,  772,  607,   44,   44,
 -       44,  772,  772,   46,   49,  772,   44,   44,   44,  772,
 -       49,  612,  772,  609,   44,   44,   44,   49,  772,   46,
 -       44,   44,   44,  608,  772,  614,   44,   44,   44,  772,
 -       49,   46,   44,   44,   44,  772,  772,   46,   49,  772,
 -      772,  611,   44,   44,   44,  772,   49,   46,   44,   44,
 -       44,  772,   49,   46,  772,   44,   44,   44,   49,  613,
 -       46,  772,  772,  772,   49,   44,   44,   44,  772,  615,
 -       46,  616,  772,  772,   49,  772,  772,   44,   44,   44,
 -       49,  617,   46,   44,   44,   44,  772,   49,   46,   44,
 -
 -       44,   44,  772,  618,   46,  772,  772,   49,   44,   44,
 -       44,  772,  772,   46,  772,  619,   44,   44,   44,   49,
 -      772,   46,  620,  772,  772,   49,  621,  772,  772,  772,
 -      772,   49,  622,   44,   44,   44,  772,  772,   46,  772,
 -       49,   44,   44,   44,  772,  772,   46,  772,   49,  772,
 -      772,  623,   44,   44,   44,  772,  772,   46,  772,  624,
 -      625,   44,   44,   44,  772,   49,  629,  772,  772,  626,
 -       44,   44,   44,   49,  772,   46,   44,   44,   44,  772,
 -      627,   46,  772,  772,   49,   44,   44,   44,  772,  772,
 -       46,  772,  772,   49,   44,   44,   44,  772,  772,   46,
 -
 -      772,  772,   49,  772,  628,   44,   44,   44,   49,  772,
 -       46,  772,  772,  630,  772,  631,  772,   49,   44,   44,
 -       44,  772,  772,   46,  772,  772,   49,   44,   44,   44,
 -      772,  772,   46,  772,  772,  772,  632,   49,  772,  772,
 -      634,   44,   44,   44,  633,  772,   46,   44,   44,   44,
 -       49,  772,   46,  635,  772,   44,   44,   44,  772,   49,
 -       46,   44,   44,   44,  772,  636,   46,   44,   44,   44,
 -      772,  772,  641,   49,  772,   44,   44,   44,  637,   49,
 -      642,   44,   44,   44,  772,  772,   46,   49,  772,  772,
 -      639,  772,  772,   49,  772,   44,   44,   44,  638,   49,
 -
 -       46,  772,  772,   44,   44,   44,  640,   49,   46,   44,
 -       44,   44,  772,   49,   46,   44,   44,   44,  772,  772,
 -       46,   44,   44,   44,  772,  772,   46,   49,  772,  643,
 -      772,   44,   44,   44,  772,   49,  649,  772,  644,  772,
 -      772,   49,  772,  772,   44,   44,   44,   49,  772,   46,
 -      772,  772,  772,   49,  650,  645,   44,   44,   44,  646,
 -      772,  652,  772,   49,  648,  772,  647,   44,   44,   44,
 -      772,  772,  653,   44,   44,   44,   49,  772,   46,   44,
 -       44,   44,  772,  772,  655,   44,   44,   44,   49,  772,
 -       46,   44,   44,   44,  772,  651,   46,  772,  772,   49,
 -
 -      772,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      772,   49,  660,  772,  772,  772,  654,   49,  656,  772,
 -       44,   44,   44,   49,  657,   46,  658,   44,   44,   44,
 -      772,  772,   46,   49,  772,  772,   44,   44,   44,   49,
 -      772,   46,   44,   44,   44,  772,  772,   46,  659,   44,
 -       44,   44,   49,  772,   46,   44,   44,   44,  661,   49,
 -       46,   44,   44,   44,  772,  772,  667,  662,   49,  772,
 -      772,   44,   44,   44,   49,  663,   46,   44,   44,   44,
 -      772,   49,  669,  772,  772,  664,  772,   49,  772,   44,
 -       44,   44,  772,   49,   46,   44,   44,   44,  772,  772,
 -
 -      671,  665,  772,   49,  772,  772,  666,  772,  772,   49,
 -       44,   44,   44,  772,  772,   46,  772,  772,  772,  668,
 -      772,   49,  772,   44,   44,   44,  772,   49,   46,   44,
 -       44,   44,  772,  772,  674,  772,   44,   44,   44,  772,
 -      670,  675,   49,   44,   44,   44,  772,  772,  676,   44,
 -       44,   44,  772,  772,   46,   49,  772,  672,  772,  772,
 -      772,   49,  772,  673,   44,   44,   44,  772,   49,   46,
 -      772,   44,   44,   44,  772,   49,  679,   44,   44,   44,
 -      772,   49,   46,  772,   44,   44,   44,  772,  677,   46,
 -       44,   44,   44,  772,  772,   46,   49,   44,   44,   44,
 -
 -      772,  772,   46,   49,  772,  772,   44,   44,   44,   49,
 -      678,  684,   44,   44,   44,  772,   49,  685,  772,   44,
 -       44,   44,   49,  680,   46,   44,   44,   44,  772,   49,
 -       46,   44,   44,   44,  772,  681,   46,  772,   49,  772,
 -      772,  772,  682,  772,   49,   44,   44,   44,  772,  683,
 -       46,   49,  772,   44,   44,   44,  772,   49,   46,   44,
 -       44,   44,  686,   49,   46,  772,   44,   44,   44,  772,
 -      688,   46,  772,  772,  772,  772,  687,   49,   44,   44,
 -       44,  772,  772,   46,  772,   49,  772,  772,  689,  772,
 -      772,   49,  690,  772,   44,   44,   44,  772,   49,   46,
 -
 -      772,  772,   44,   44,   44,  692,  691,   46,  772,  772,
 -       49,   44,   44,   44,  772,  772,   46,   44,   44,   44,
 -      772,  772,   46,   44,   44,   44,   49,  772,  698,  693,
 -       44,   44,   44,  694,   49,  699,   44,   44,   44,  772,
 -      695,   46,  772,   49,  772,   44,   44,   44,  772,   49,
 -       46,  772,   44,   44,   44,   49,  697,   46,  772,  696,
 -      772,  772,   49,  772,   44,   44,   44,  772,   49,   46,
 -       44,   44,   44,  772,  702,   46,  772,   49,  772,  700,
 -       44,   44,   44,  772,   49,  705,  772,   44,   44,   44,
 -      772,  772,   46,   44,   44,   44,   49,  772,  707,  772,
 -
 -      772,  701,   49,  703,   44,   44,   44,  772,  772,  708,
 -      772,  772,   49,  772,  772,   44,   44,   44,  704,   49,
 -       46,   44,   44,   44,  772,   49,   46,  706,   44,   44,
 -       44,  710,  772,   46,  772,  772,   49,   44,   44,   44,
 -      772,  772,  712,   44,   44,   44,  772,   49,   46,   44,
 -       44,   44,  772,   49,  714,  772,   44,   44,   44,  715,
 -       49,   46,  772,   44,   44,   44,  711,  709,  717,   49,
 -      772,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      772,   49,   46,  772,   44,   44,   44,  772,   49,   46,
 -      772,  713,   44,   44,   44,   49,  772,   46,  772,   44,
 -
 -       44,   44,  772,   49,   46,  716,  772,  772,  772,   49,
 -       44,   44,   44,  772,  772,   46,   49,  772,  718,  772,
 -      719,   44,   44,   44,   49,  772,   46,  720,   44,   44,
 -       44,   49,  772,   46,  772,  772,  772,  772,  722,  772,
 -      721,  772,   49,  772,   44,   44,   44,  772,  772,   46,
 -       44,   44,   44,   49,  726,   46,  772,  723,  772,  772,
 -       49,  772,   44,   44,   44,  772,  724,   46,   44,   44,
 -       44,  772,  772,   46,  772,  772,   49,  772,  725,   44,
 -       44,   44,   49,  772,  730,  772,  772,   44,   44,   44,
 -      772,  727,   46,  772,   49,  772,  772,  731,  772,  772,
 -
 -       49,   44,   44,   44,  772,  772,   46,  772,  728,  772,
 -      772,   49,  772,   44,   44,   44,  772,  729,   46,   49,
 -       44,   44,   44,  772,  772,   46,   44,   44,   44,  772,
 -      772,  735,  772,   49,   44,   44,   44,  772,  772,   46,
 -      732,  772,   44,   44,   44,   49,  772,   46,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,   49,   46,
 -      772,  733,  772,  734,  772,  772,   49,   44,   44,   44,
 -      772,  772,   46,  736,   49,  772,   44,   44,   44,  772,
 -       49,   46,  772,   44,   44,   44,   49,  772,  742,  772,
 -       44,   44,   44,  772,  737,   46,  772,  738,  772,   49,
 -
 -      772,  739,  772,  772,  740,   44,   44,   44,   49,  772,
 -       46,   44,   44,   44,  741,   49,  745,  772,   44,   44,
 -       44,  772,   49,   46,   44,   44,   44,  772,  772,   46,
 -       44,   44,   44,  743,  772,   46,  772,   49,  772,  772,
 -       44,   44,   44,   49,  744,   46,  772,   44,   44,   44,
 -       49,  772,   46,   44,   44,   44,   49,  746,   46,   44,
 -       44,   44,   49,  747,   46,   44,   44,   44,  772,  772,
 -       46,  772,   49,  772,  772,   44,   44,   44,  748,   49,
 -       46,   44,   44,   44,  772,   49,   46,   44,   44,   44,
 -      749,   49,   46,  772,  772,  772,  772,   49,  750,  772,
 -
 -      751,  772,  772,  772,  772,  772,  752,   49,  753,   44,
 -       44,   44,  772,   49,   46,   44,   44,   44,  772,   49,
 -       46,  772,   44,   44,   44,  772,  754,   46,  772,   44,
 -       44,   44,  772,  755,  760,   44,   44,   44,  756,  772,
 -       46,   49,  772,   44,   44,   44,  772,   49,   46,  772,
 -      772,   44,   44,   44,   49,  772,   46,  757,  758,  772,
 -      772,   49,  772,  772,  772,  759,  772,   49,  772,   44,
 -       44,   44,  772,  761,  764,   49,   44,   44,   44,  772,
 -      772,   46,  772,   49,   44,   44,   44,  772,  772,   46,
 -      762,  763,   44,   44,   44,  772,  772,  767,   44,   44,
 -
 -       44,   49,  772,   46,   44,   44,   44,  772,   49,   46,
 -       44,   44,   44,  772,  772,   46,   49,  765,   44,   44,
 -       44,  772,  772,  771,   49,  772,  772,  766,  772,  772,
 -       49,  772,  772,  772,  772,  772,   49,  768,  772,  772,
 -      772,  772,   49,  772,  772,  772,  772,  772,  772,  772,
 -       49,  772,  772,  772,  769,  772,  772,  772,  772,  772,
 -      772,  770,   36,   36,   36,   36,   36,   36,   36,   45,
 -       45,   45,   45,   45,   45,   45,   66,  772,   66,   66,
 -       66,   66,   66,   85,  772,   85,  772,   85,   85,   85,
 -       87,   87,   87,   87,   87,   87,   87,   92,   92,   92,
 -
 -       92,   92,   92,   92,  136,  772,  136,  136,  136,  136,
 -      136,   87,   87,  772,   87,  148,  148,  148,  148,  148,
 -      213,  213,  274,  274,  341,  341,   87,   87,   11,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772
--    } ;
--
- static yyconst flex_int16_t yy_chk[1076] =
 -static yyconst flex_int16_t yy_chk[5690] =
--    {   0,
--        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
--        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
--        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
--        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
--        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-         1,    1,    1,    3,    3,    3,    4,    4,    4,    3,
-         9,    7,    4,    5,    5,    8,    5,    5,    5,    5,
-         5,    5,    5,    5,    5,    5,   10,    9,   21,   13,
-         5,   13,    5,   21,    5,   56,   20,   20,   20,   56,
-         5,    5,    7,   10,    5,   20,    8,   34,    5,   34,
 -        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 -        3,    3,    3,    4,    4,    4,    3,   27,    7,    4,
 -        5,    5,    8,    5,    5,    5,    5,    5,    5,    5,
 -        5,    5,    5,    9,   13,   10,   13,   21,    5,    5,
 -       27,    5,   21,  340,    5,   25,    5,   25,    5,   26,
--
-        39,   48,   39,    5,   48,   20,  658,   48,  659,    5,
-         5,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-        15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
 -       25,   25,   25,  273,    5,    5,    7,    9,    5,   10,
 -        8,  212,    5,   28,   26,   32,   17,    5,   17,   17,
 -       17,  148,   31,    5,    5,   15,   15,   15,   17,   33,
 -       15,   19,  143,   19,   19,   19,   28,   31,   32,   20,
 -       20,   20,   44,   19,   17,   92,   37,   15,   37,   20,
 -       15,   42,   33,   42,   75,   75,   75,   15,   89,   19,
 -       15,   77,   15,   15,   15,   20,   85,   15,   15,   44,
--       15,   15,   15,   15,   15,   15,   15,   15,   15,   15,
-        15,   15,   15,   15,   17,   98,   17,   17,   17,   19,
-        50,   19,   19,   19,   41,   17,   25,   98,   25,   50,
-        19,   25,   25,   25,   22,   17,   22,   22,   22,   49,
-        19,   52,   81,   49,   41,   22,   49,   51,  663,   58,
 -       22,   77,   22,   22,   22,   45,   45,   45,   87,   78,
 -       45,   79,   22,   47,   47,   47,   82,  137,   47,   48,
--
-        52,   51,   52,   58,   51,   22,   42,   49,   42,  664,
-        53,   53,   81,   42,   53,   42,   42,   42,   62,   53,
-        42,   42,   62,   42,   42,   42,   42,   42,   42,   42,
-        42,   42,   42,   46,   57,  120,   59,   57,   57,  120,
-        46,   72,   72,   72,   60,   59,   59,   57,   60,   57,
-        59,  113,  113,   46,   73,   73,   73,   46,   64,   64,
-        64,   46,   60,   68,   68,   68,   91,   64,   46,   97,
-       239,   46,   68,   46,   46,   91,   65,   64,   65,   65,
-        65,  102,   68,   66,   97,   66,  666,   65,   66,   66,
-        66,   67,  214,   67,   67,   67,  214,   65,   94,   94,
 -       48,   48,  139,   49,   48,   76,   76,   76,   22,   78,
 -       49,   50,   50,   50,   79,   87,   50,   45,  139,   82,
 -      137,   51,   51,   51,   84,   47,   51,   43,   41,   80,
 -       49,   48,   81,   39,   49,   47,   38,  138,   49,   52,
 -       52,   52,  142,   50,   52,   49,   24,   48,   49,   80,
 -       49,   49,   81,   51,   53,   53,   53,  138,  142,   53,
 -       14,   50,  140,   54,   54,   54,   51,   11,   54,   51,
 -        0,   52,   51,    0,   52,   55,   55,   55,   52,    0,
 -       55,   52,   57,   57,   57,  140,   53,   57,   56,   56,
 -       56,    0,   52,   56,    0,   54,  141,   58,   58,   58,
--
-        99,  606,   67,   99,  202,  202,  240,   94,  102,  239,
-       240,  202,   67,   88,   88,   88,  360,  380,  312,  667,
-        88,   88,   88,  312,  119,  119,  119,  380,   88,   88,
-        88,   88,   88,   88,  119,  606,  119,  668,  360,  367,
-       119,  141,  141,  141,  367,  669,  431,  505,  141,  141,
-       141,  431,  505,  672,  673,  674,  141,  141,  141,  141,
-       141,  141,  204,  204,  204,  551,  367,  221,  550,  204,
-       204,  204,  221,  550,  610,  675,  676,  204,  204,  204,
-       204,  204,  204,  463,  677,  678,  505,  463,  679,  680,
-       681,  682,  551,  683,  686,  687,  688,  689,  690,  692,
 -        0,   53,   58,   59,   59,   59,    0,   55,   59,  206,
 -       53,   54,    0,   55,   57,   54,  141,   57,   54,    0,
 -       56,    0,   55,    0,   55,  206,    0,   56,   56,   58,
 -        0,   56,   58,  209,    0,   59,   56,   61,   61,   61,
 -        0,    0,   61,    0,    0,   62,   62,   62,    0,  209,
 -       62,    0,   59,    0,    0,    0,   59,   60,   60,   60,
 -        0,    0,   60,    0,    0,   63,   63,   63,    0,   61,
 -       63,    0,   61,    0,    0,    0,   61,   62,   64,   64,
 -       64,    0,    0,   64,   62,   65,   65,   65,    0,   60,
 -       65,    0,   60,   62,   62,   60,   60,   63,   62,   67,
--
-       687,  610,  221,  695,  696,  697,  221,  265,  265,  265,
-       699,  701,  702,  704,  265,  265,  265,  705,  706,  707,
-       708,  709,  265,  265,  265,  265,  265,  265,  710,  711,
-       712,  713,  714,  715,  717,  718,  719,  720,  722,  723,
-       724,  725,  726,  727,  729,  730,  732,  733,  734,  735,
-       736,  737,  738,  739,  740,  741,  742,  743,  744,  745,
-       747,  748,  749,  751,  752,  754,  755,  756,  759,  759,
-       759,  759,  759,  759,  759,  760,  656,  760,  760,  760,
-       760,  760,  761,  654,  761,  652,  761,  761,  761,  762,
-       762,  762,  762,  762,  762,  762,  763,  763,  763,  763,
 -       67,   67,    0,    0,   63,   60,    0,   60,   63,   67,
 -       64,   68,    0,   68,   68,   68,    0,   65,    0,    0,
 -       65,    0,   63,   68,   65,   67,   69,    0,   69,   64,
 -        0,   69,   69,   69,   70,    0,   70,   70,   70,   68,
 -       71,   71,   71,   90,   90,   90,   70,    0,   90,    0,
 -       71,   91,   91,   91,    0,    0,   91,    0,   93,   93,
 -       93,    0,   70,   93,    0,    0,   71,   96,   96,   96,
 -        0,    0,   96,    0,    0,   90,   95,   95,   95,    0,
 -       90,   95,    0,   91,    0,    0,    0,    0,    0,    0,
 -       93,    0,   91,   94,   94,   94,    0,    0,    0,   96,
--
-       763,  763,  763,  764,  651,  764,  764,  764,  764,  764,
-       765,  765,  650,  765,  766,  766,  766,  766,  766,  767,
-       767,  768,  768,  769,  769,  770,  770,  649,  648,  647,
-       645,  644,  643,  642,  640,  637,  636,  634,  633,  632,
-       631,  630,  629,  626,  625,  624,  623,  622,  621,  620,
-       619,  618,  617,  616,  614,  613,  612,  611,  609,  608,
-       607,  605,  604,  603,  602,  601,  599,  597,  595,  594,
-       593,  592,  591,  589,  587,  584,  583,  582,  581,  580,
-       579,  578,  577,  576,  575,  572,  571,  570,  569,  568,
-       566,  565,  564,  563,  562,  561,  560,  559,  558,  557,
 -       94,   94,   94,   94,   94,    0,    0,    0,   95,    0,
 -       96,    0,    0,    0,    0,   94,   94,   94,   94,   94,
 -       94,    0,   97,   97,   97,    0,   95,   97,    0,   98,
 -       98,   98,    0,    0,   98,   99,   99,   99,    0,    0,
 -       99,  100,  100,  100,    0,    0,  100,  101,  101,  101,
 -        0,    0,  101,    0,   97,    0,    0,  102,  102,  102,
 -       97,   98,  102,  105,  105,  105,    0,   99,  105,   97,
 -      103,  103,  103,  100,    0,  103,    0,  100,  100,  101,
 -      104,  104,  104,   98,  101,  104,  100,   99,    0,  102,
 -        0,  106,  106,  106,    0,  105,  106,    0,    0,    0,
--
-       556,  555,  554,  553,  552,  549,  547,  546,  545,  544,
-       543,  542,  541,  540,  539,  538,  536,  535,  534,  533,
-       532,  531,  530,  529,  528,  526,  525,  524,  523,  522,
-       521,  519,  517,  516,  513,  512,  511,  510,  509,  508,
-       507,  506,  504,  503,  502,  500,  499,  498,  497,  496,
-       495,  494,  493,  492,  491,  490,  489,  488,  487,  484,
-       482,  481,  480,  479,  478,  477,  476,  475,  474,  473,
-       472,  471,  470,  469,  467,  466,  465,  464,  462,  459,
-       458,  457,  456,  455,  454,  453,  452,  451,  450,  449,
-       448,  447,  446,  445,  444,  443,  442,  441,  440,  439,
 -      102,    0,  103,  107,  107,  107,    0,  103,  107,    0,
 -        0,  105,  104,  107,  105,    0,    0,  104,    0,  108,
 -      108,  108,  103,  106,  108,  109,  109,  109,    0,  104,
 -      109,  110,  110,  110,    0,  107,  110,  111,  111,  111,
 -        0,  110,  111,    0,  112,  112,  112,    0,  106,  112,
 -        0,  108,    0,    0,  113,  113,  113,  109,  108,  113,
 -      114,  114,  114,  110,    0,  114,  115,  115,  115,  111,
 -        0,  115,  111,  116,  116,  116,  112,  109,  116,    0,
 -        0,  112,  117,  117,  117,    0,  113,  117,    0,    0,
 -      113,    0,  114,    0,  118,  118,  118,    0,  115,  118,
--
-       438,  436,  435,  434,  433,  430,  429,  428,  427,  426,
-       425,  424,  423,  422,  421,  420,  418,  417,  416,  415,
-       414,  413,  411,  410,  409,  408,  407,  406,  405,  404,
-       403,  402,  401,  400,  399,  398,  397,  396,  395,  394,
-       393,  392,  391,  390,  389,  388,  387,  386,  385,  384,
-       382,  381,  378,  377,  376,  375,  374,  373,  371,  370,
-       369,  368,  366,  364,  363,  362,  361,  359,  358,  357,
-       356,  355,  354,  353,  352,  351,  350,  348,  347,  346,
-       345,  344,  343,  342,  341,  340,  339,  338,  337,  336,
-       335,  334,  333,  331,  330,  326,  325,  324,  319,  318,
 -        0,  114,    0,  115,    0,  116,  119,  119,  119,    0,
 -        0,  119,    0,    0,  117,  120,  120,  120,    0,  116,
 -      120,    0,  121,  121,  121,  120,  118,  121,  122,  122,
 -      122,    0,    0,  122,  117,  123,  123,  123,  119,    0,
 -      123,    0,    0,  124,  124,  124,  118,  120,  124,    0,
 -      126,  126,  126,    0,  121,  126,  119,  119,    0,    0,
 -      122,    0,    0,    0,  127,  127,  127,  123,    0,  127,
 -        0,    0,  121,    0,  123,  124,  122,    0,  128,  128,
 -      128,    0,  126,  128,  129,  129,  129,    0,    0,  129,
 -        0,    0,  124,  125,  125,  125,  127,    0,  125,    0,
--
-       317,  316,  315,  314,  313,  311,  310,  309,  308,  307,
-       306,  305,  303,  302,  301,  300,  299,  298,  296,  295,
-       294,  293,  292,  291,  290,  289,  288,  287,  286,  285,
-       284,  282,  281,  280,  279,  278,  276,  275,  274,  273,
-       272,  270,  269,  267,  266,  264,  263,  262,  261,  259,
-       258,  257,  256,  255,  254,  253,  252,  251,  250,  249,
-       248,  247,  246,  245,  244,  243,  242,  241,  238,  237,
-       236,  235,  234,  233,  232,  231,  230,  229,  228,  227,
-       226,  225,  224,  223,  222,  220,  219,  218,  217,  216,
-       215,  213,  212,  211,  210,  209,  208,  207,  206,  205,
 -      126,  127,    0,    0,  126,    0,    0,  130,  130,  130,
 -      128,    0,  130,  128,    0,    0,  129,  131,  131,  131,
 -      129,    0,  131,    0,    0,  125,    0,    0,  125,  125,
 -      125,    0,  132,  132,  132,    0,    0,  132,  125,  130,
 -      125,  133,  133,  133,  125,    0,  133,    0,    0,  131,
 -      134,  134,  134,    0,    0,  134,    0,    0,  130,    0,
 -      135,  135,  135,  131,  132,  135,  146,  146,  146,    0,
 -        0,  146,    0,  133,  151,  151,  151,    0,    0,  151,
 -      133,  132,  134,    0,  147,  147,  147,    0,    0,  147,
 -        0,    0,  135,    0,    0,  134,    0,    0,  146,  152,
--
-       203,  200,  197,  196,  195,  194,  193,  192,  191,  190,
-       189,  188,  187,  186,  185,  184,  183,  182,  181,  180,
-       179,  178,  177,  176,  175,  174,  173,  172,  171,  170,
-       169,  168,  167,  166,  165,  164,  163,  162,  160,  159,
-       158,  157,  156,  155,  154,  153,  152,  151,  150,  149,
-       148,  147,  146,  145,  144,  143,  142,  139,  138,  137,
-       134,  133,  132,  131,  129,  128,  127,  126,  125,  124,
-       123,  122,  121,  118,  117,  116,  115,  114,  112,  111,
-       110,  109,  108,  107,  106,  105,  104,  103,  101,  100,
-        96,   95,   93,   92,   90,   89,   86,   85,   84,   83,
 -      152,  152,    0,    0,  152,    0,  151,    0,    0,  151,
 -      135,    0,    0,    0,    0,  146,  147,    0,    0,    0,
 -        0,    0,    0,    0,    0,  147,  150,  150,  150,    0,
 -        0,  152,    0,  150,  150,  150,  150,  150,  152,  153,
 -      153,  153,    0,    0,  153,    0,    0,    0,  150,  150,
 -      150,  150,  150,  150,  154,  154,  154,    0,    0,  154,
 -      155,  155,  155,    0,    0,  155,    0,  156,  156,  156,
 -      155,  153,  156,    0,    0,  157,  157,  157,  153,    0,
 -      157,    0,  158,  158,  158,    0,  154,  158,    0,    0,
 -        0,    0,  155,  159,  159,  159,    0,    0,  159,  156,
--
-        79,   78,   76,   75,   74,   61,   55,   54,   47,   45,
-        44,   40,   38,   36,   35,   30,   29,   28,   24,   14,
-        11,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758,  758,  758,  758,  758,  758,
-       758,  758,  758,  758,  758
 -        0,    0,  156,  160,  160,  160,  154,  157,  160,    0,
 -      161,  161,  161,    0,  158,  161,    0,    0,  162,  162,
 -      162,    0,    0,  162,    0,  159,    0,  158,  157,  163,
 -      163,  163,  159,    0,  163,  160,    0,    0,  164,  164,
 -      164,    0,  161,  164,  165,  165,  165,    0,  161,  165,
 -      162,    0,  160,  162,  166,  166,  166,    0,    0,  166,
 -        0,  163,  167,  167,  167,    0,    0,  167,  163,    0,
 -      164,    0,  168,  168,  168,    0,  165,  168,    0,    0,
 -      169,  169,  169,  164,    0,  169,  166,  165,  171,  171,
 -      171,    0,    0,  171,  167,  172,  172,  172,  166,    0,
 -
 -      172,  173,  173,  173,  168,    0,  173,    0,  174,  174,
 -      174,    0,  169,  174,  167,  169,    0,  176,  176,  176,
 -      171,  168,  176,  177,  177,  177,    0,  172,  177,    0,
 -        0,    0,    0,  173,  172,  171,  173,  175,  175,  175,
 -      174,    0,  175,  178,  178,  178,    0,  175,  178,  176,
 -        0,    0,    0,  178,    0,  177,  179,  179,  179,  174,
 -        0,  179,    0,    0,  177,    0,    0,  176,    0,  175,
 -        0,  180,  180,  180,    0,  178,  180,  181,  181,  181,
 -        0,    0,  181,    0,  182,  182,  182,    0,  179,  182,
 -        0,  183,  183,  183,    0,  179,  183,  184,  184,  184,
 -
 -        0,    0,  184,  180,    0,  185,  185,  185,    0,  181,
 -      185,    0,    0,    0,  180,    0,  182,    0,    0,  182,
 -      186,  186,  186,  183,    0,  186,  181,    0,    0,  184,
 -      187,  187,  187,    0,    0,  187,    0,  185,    0,  188,
 -      188,  188,  183,    0,  188,    0,  184,    0,  189,  189,
 -      189,    0,  186,  189,    0,    0,  185,    0,  190,  190,
 -      190,    0,  187,  190,    0,  186,    0,  191,  191,  191,
 -      187,  188,  191,  192,  192,  192,    0,    0,  192,    0,
 -      189,    0,  188,    0,    0,    0,  189,  193,  193,  193,
 -      190,    0,  193,  194,  194,  194,    0,    0,  194,  191,
 -
 -        0,  190,  195,  195,  195,  192,    0,  195,  192,  196,
 -      196,  196,    0,    0,  196,  191,    0,    0,    0,  193,
 -        0,    0,  197,  197,  197,  194,  193,  197,  198,  198,
 -      198,    0,  194,  198,  195,  199,  199,  199,    0,    0,
 -      199,  196,  200,  200,  200,    0,    0,  200,  196,    0,
 -        0,    0,    0,    0,  197,    0,  195,  201,  201,  201,
 -      198,    0,  201,    0,    0,  198,  197,  199,  202,  202,
 -      202,    0,    0,  202,  200,    0,  203,  203,  203,    0,
 -        0,  203,  199,    0,    0,  204,  204,  204,    0,  201,
 -      204,    0,    0,    0,  200,    0,  201,  205,  205,  205,
 -
 -      202,    0,  205,    0,    0,    0,    0,  202,  203,  214,
 -      214,  214,    0,    0,  214,    0,    0,  204,    0,    0,
 -      215,  215,  215,  214,  214,  215,  203,    0,  204,  205,
 -        0,  214,    0,    0,    0,  217,  217,  217,    0,    0,
 -      217,  214,    0,    0,    0,    0,    0,    0,  205,  218,
 -      218,  218,  215,    0,  218,    0,    0,    0,    0,    0,
 -        0,    0,    0,  215,  216,  216,  216,  217,    0,    0,
 -        0,  216,  216,  216,  216,  216,    0,  219,  219,  219,
 -        0,  218,  219,    0,    0,    0,  216,  216,  216,  216,
 -      216,  216,  217,  220,  220,  220,  218,    0,  220,  221,
 -
 -      221,  221,    0,    0,  221,  222,  222,  222,    0,  219,
 -      222,    0,  223,  223,  223,    0,    0,  223,  224,  224,
 -      224,    0,    0,  224,    0,  220,    0,  225,  225,  225,
 -        0,  221,  225,  227,  227,  227,    0,  222,  227,  221,
 -      228,  228,  228,  220,  223,  228,  226,  226,  226,    0,
 -      224,  226,    0,  223,    0,    0,  226,    0,    0,  225,
 -      226,  224,  229,  229,  229,  227,    0,  229,  225,  230,
 -      230,  230,  228,    0,  230,  231,  231,  231,  226,    0,
 -      231,  232,  232,  232,    0,    0,  232,    0,    0,  228,
 -        0,    0,    0,    0,  229,  233,  233,  233,    0,    0,
 -
 -      233,  230,    0,    0,    0,  233,    0,  231,    0,  234,
 -      234,  234,  229,  232,  234,  235,  235,  235,    0,    0,
 -      235,    0,  230,    0,    0,  231,    0,  233,  236,  236,
 -      236,    0,  232,  236,  237,  237,  237,    0,    0,  237,
 -        0,  234,  233,    0,    0,    0,  233,  235,  234,  238,
 -      238,  238,    0,  235,  238,    0,  239,  239,  239,    0,
 -      236,  239,  240,  240,  240,    0,  237,  240,  241,  241,
 -      241,    0,    0,  241,  242,  242,  242,    0,    0,  242,
 -      236,  238,    0,    0,  237,    0,    0,  238,  239,    0,
 -        0,  243,  243,  243,  240,  239,  243,  244,  244,  244,
 -
 -      241,    0,  244,  241,    0,  240,  242,  245,  245,  245,
 -        0,    0,  245,  242,  246,  246,  246,    0,    0,  246,
 -      247,  247,  247,  243,    0,  247,  248,  248,  248,  244,
 -        0,  248,  249,  249,  249,    0,    0,  249,    0,  245,
 -        0,    0,  243,  250,  250,  250,  246,    0,  250,    0,
 -        0,    0,  247,    0,    0,  245,    0,    0,  248,    0,
 -      251,  251,  251,    0,  249,  251,  247,  246,    0,  252,
 -      252,  252,    0,    0,  252,  250,    0,  253,  253,  253,
 -      249,  248,  253,    0,    0,    0,  250,    0,  254,  254,
 -      254,    0,  251,  254,  255,  255,  255,    0,    0,  255,
 -
 -        0,  252,  256,  256,  256,    0,    0,  256,  252,  253,
 -        0,  251,  252,    0,    0,  253,  257,  257,  257,    0,
 -      254,  257,  258,  258,  258,    0,  255,  258,  259,  259,
 -      259,    0,    0,  259,  256,    0,  254,  260,  260,  260,
 -        0,  255,  260,    0,    0,    0,    0,    0,  257,    0,
 -        0,    0,  256,    0,  258,    0,  261,  261,  261,    0,
 -      259,  261,  262,  262,  262,    0,    0,  262,    0,  260,
 -      263,  263,  263,  257,    0,  263,  260,  258,  259,  264,
 -      264,  264,    0,    0,  264,  265,  265,  265,  261,    0,
 -      265,  266,  266,  266,  262,    0,  266,    0,  267,  267,
 -
 -      267,  262,  263,  267,    0,    0,  261,    0,    0,  263,
 -        0,  264,    0,    0,  268,  268,  268,  265,  264,  268,
 -      269,  269,  269,  266,    0,  269,    0,  270,  270,  270,
 -      267,    0,  270,  275,  275,  275,    0,    0,  275,  276,
 -      276,  276,    0,    0,  276,    0,  268,    0,  277,  277,
 -      277,    0,  269,  277,    0,  278,  278,  278,  269,  270,
 -      278,  280,  280,  280,    0,  275,  280,  281,  281,  281,
 -      270,  276,  281,    0,  283,  283,  283,    0,    0,  283,
 -      277,    0,    0,  284,  284,  284,  277,  278,  284,  286,
 -      286,  286,    0,  280,  286,    0,    0,    0,    0,  281,
 -
 -        0,    0,  278,  279,  279,  279,  283,    0,    0,    0,
 -      279,  279,  279,  279,  279,  284,    0,    0,    0,  281,
 -        0,  286,  283,    0,    0,  279,  279,  279,  279,  279,
 -      279,  284,    0,    0,  286,  287,  287,  287,    0,    0,
 -      287,  288,  288,  288,    0,    0,  288,  289,  289,  289,
 -        0,    0,  289,    0,  290,  290,  290,    0,    0,  290,
 -      292,  292,  292,    0,    0,  292,    0,  287,    0,  293,
 -      293,  293,    0,  288,  293,    0,  288,    0,    0,  289,
 -        0,    0,  287,    0,    0,  289,  290,    0,  294,  294,
 -      294,    0,  292,  294,    0,  295,  295,  295,    0,    0,
 -
 -      295,  293,  290,  296,  296,  296,    0,    0,  296,    0,
 -        0,  292,    0,  296,  298,  298,  298,    0,  293,  298,
 -      294,    0,    0,  299,  299,  299,  294,  295,  299,    0,
 -        0,  300,  300,  300,  295,  296,  300,  301,  301,  301,
 -        0,  300,  301,  302,  302,  302,  298,    0,  302,    0,
 -        0,  303,  303,  303,    0,  299,  303,    0,  299,    0,
 -      304,  304,  304,  300,  298,  304,  305,  305,  305,  301,
 -        0,  305,    0,    0,    0,  302,    0,  306,  306,  306,
 -        0,  302,  306,  303,  307,  307,  307,  306,    0,  307,
 -        0,    0,  304,    0,  303,    0,    0,    0,  305,    0,
 -
 -      304,  308,  308,  308,  305,    0,  308,    0,    0,  306,
 -      309,  309,  309,    0,    0,  309,  307,  310,  310,  310,
 -        0,    0,  310,  312,  312,  312,    0,    0,  312,    0,
 -        0,  307,    0,  308,  313,  313,  313,    0,    0,  313,
 -        0,    0,  309,  314,  314,  314,    0,    0,  314,  310,
 -        0,  308,  315,  315,  315,  312,    0,  315,    0,    0,
 -      309,    0,  316,  316,  316,  310,  313,  316,    0,    0,
 -      312,  317,  317,  317,    0,  314,  317,    0,    0,    0,
 -        0,    0,  314,    0,  315,    0,  313,  319,  319,  319,
 -        0,    0,  319,    0,  316,    0,  320,  320,  320,    0,
 -
 -      315,  320,    0,  317,  321,  321,  321,    0,    0,  321,
 -      316,  322,  322,  322,    0,    0,  322,    0,    0,  319,
 -        0,  322,  317,    0,  323,  323,  323,    0,  320,  323,
 -      324,  324,  324,    0,    0,  324,  321,  325,  325,  325,
 -        0,    0,  325,  322,    0,    0,  320,  326,  326,  326,
 -        0,    0,  326,  327,  327,  327,  323,  326,  327,    0,
 -      321,    0,  324,  327,    0,  328,  328,  328,  324,  325,
 -      328,  323,  329,  329,  329,  325,    0,  329,    0,  326,
 -        0,  330,  330,  330,    0,  327,  330,    0,  331,  331,
 -      331,    0,    0,  331,  332,  332,  332,  328,    0,  332,
 -
 -      333,  333,  333,    0,  329,  333,  338,  338,  338,    0,
 -        0,  338,    0,  330,    0,    0,  338,    0,    0,  328,
 -      331,    0,  329,    0,  330,    0,  332,    0,  339,  339,
 -      339,    0,  333,  339,  344,  344,  344,    0,  338,  344,
 -      331,  345,  345,  345,    0,    0,  345,    0,  347,  347,
 -      347,    0,  333,  347,  348,  348,  348,    0,  347,  348,
 -      339,    0,  349,  349,  349,    0,  344,  349,    0,  350,
 -      350,  350,    0,  345,  350,    0,  339,    0,    0,    0,
 -      347,  344,  345,  351,  351,  351,  348,    0,  351,    0,
 -        0,  352,  352,  352,  349,    0,  352,    0,    0,  348,
 -
 -        0,  350,  353,  353,  353,    0,    0,  353,  350,  354,
 -      354,  354,  349,    0,  354,  351,  355,  355,  355,    0,
 -        0,  355,  351,  352,  354,  356,  356,  356,    0,    0,
 -      356,  357,  357,  357,  353,    0,  357,    0,    0,    0,
 -      353,  354,    0,  352,  358,  358,  358,    0,  355,  358,
 -        0,  359,  359,  359,    0,    0,  359,  356,    0,  360,
 -      360,  360,    0,  357,  360,    0,    0,    0,    0,  355,
 -      357,    0,  361,  361,  361,  356,  358,  361,    0,  362,
 -      362,  362,  358,  359,  362,    0,    0,  364,  364,  364,
 -        0,  360,  364,    0,    0,    0,  359,    0,  360,    0,
 -
 -      365,  365,  365,    0,  361,  365,    0,  366,  366,  366,
 -        0,  362,  366,    0,    0,    0,    0,  362,  361,  364,
 -      367,  367,  367,    0,    0,  367,  368,  368,  368,    0,
 -        0,  368,  365,  369,  369,  369,    0,  364,  369,  366,
 -      365,    0,  366,  370,  370,  370,    0,    0,  370,    0,
 -        0,    0,  367,    0,  371,  371,  371,    0,  368,  371,
 -        0,  372,  372,  372,  368,  369,  372,  373,  373,  373,
 -      367,    0,  373,    0,    0,  370,    0,  373,  374,  374,
 -      374,    0,    0,  374,    0,  369,  371,  375,  375,  375,
 -        0,    0,  375,  372,    0,    0,  376,  376,  376,  373,
 -
 -      370,  376,  377,  377,  377,  371,    0,  377,    0,    0,
 -      374,    0,  374,    0,  372,    0,  378,  378,  378,  375,
 -        0,  378,  380,  380,  380,    0,    0,  380,  376,    0,
 -      381,  381,  381,    0,  377,  381,    0,    0,    0,  375,
 -      381,    0,    0,    0,    0,    0,  376,  377,  378,    0,
 -      382,  382,  382,    0,  380,  382,  383,  383,  383,    0,
 -        0,  383,  381,    0,    0,  384,  384,  384,  378,  381,
 -      384,    0,  380,    0,    0,  384,  385,  385,  385,    0,
 -        0,  385,  382,    0,    0,    0,  385,  382,  383,  387,
 -      387,  387,    0,    0,  387,    0,    0,  384,  388,  388,
 -
 -      388,  383,    0,  388,  389,  389,  389,    0,  385,  389,
 -      390,  390,  390,    0,    0,  390,    0,  391,  391,  391,
 -      390,  387,  391,  392,  392,  392,    0,    0,  392,    0,
 -      388,    0,    0,  392,    0,    0,  389,    0,    0,  389,
 -      387,    0,  390,  394,  394,  394,    0,    0,  394,  391,
 -      388,  395,  395,  395,    0,  392,  395,    0,  394,  396,
 -      396,  396,    0,    0,  396,  398,  398,  398,    0,  391,
 -      398,  399,  399,  399,    0,  394,  399,  400,  400,  400,
 -        0,    0,  400,  395,    0,  401,  401,  401,    0,    0,
 -      401,  396,    0,    0,    0,  401,  395,  398,    0,  402,
 -
 -      402,  402,    0,  399,  402,    0,  396,    0,    0,  400,
 -      403,  403,  403,    0,  400,  403,  398,  401,  404,  404,
 -      404,    0,    0,  404,  405,  405,  405,    0,  404,  405,
 -        0,  402,    0,  406,  406,  406,    0,    0,  406,  407,
 -      407,  407,  403,    0,  407,  402,  408,  408,  408,  407,
 -      404,  408,  409,  409,  409,    0,  405,  409,    0,    0,
 -        0,    0,    0,  405,  403,  406,    0,  410,  410,  410,
 -        0,  407,  410,    0,  412,  412,  412,    0,  408,  412,
 -      406,  413,  413,  413,  409,    0,  413,  411,  411,  411,
 -        0,  408,  411,    0,    0,  409,    0,  411,    0,  410,
 -
 -        0,    0,  414,  414,  414,  410,  412,  414,    0,    0,
 -      415,  415,  415,  413,    0,  415,    0,  412,    0,  411,
 -      416,  416,  416,    0,    0,  416,  417,  417,  417,    0,
 -        0,  417,  413,    0,  414,  418,  418,  418,    0,    0,
 -      418,  414,  415,    0,    0,  415,  419,  419,  419,    0,
 -        0,  419,  416,    0,    0,  420,  420,  420,  417,  416,
 -      420,  421,  421,  421,    0,    0,  421,  418,    0,  417,
 -        0,    0,  418,    0,  422,  422,  422,    0,  419,  422,
 -        0,  423,  423,  423,    0,  419,  423,  420,    0,    0,
 -      420,    0,    0,  421,  424,  424,  424,    0,    0,  424,
 -
 -      421,    0,  425,  425,  425,    0,  422,  425,    0,  427,
 -      427,  427,    0,  423,  427,  428,  428,  428,    0,    0,
 -      428,    0,    0,  429,  429,  429,  424,    0,  429,    0,
 -      430,  430,  430,    0,  425,  430,    0,  431,  431,  431,
 -      425,  427,  431,    0,  424,    0,    0,  428,  432,  432,
 -      432,    0,    0,  432,  428,  429,    0,  427,  434,  434,
 -      434,  429,  430,  434,    0,  435,  435,  435,    0,  431,
 -      435,    0,  436,  436,  436,    0,    0,  436,    0,    0,
 -      432,  430,    0,  437,  437,  437,    0,  432,  437,    0,
 -      434,  438,  438,  438,    0,    0,  438,  435,    0,    0,
 -
 -      439,  439,  439,  434,  436,  439,  440,  440,  440,    0,
 -        0,  440,  441,  441,  441,  437,  435,  441,    0,    0,
 -      436,    0,    0,  438,  442,  442,  442,    0,    0,  442,
 -        0,    0,  439,    0,  443,  443,  443,    0,  440,  443,
 -      437,    0,    0,  438,  441,    0,  444,  444,  444,    0,
 -        0,  444,  439,    0,    0,  441,  442,    0,    0,  440,
 -      445,  445,  445,    0,    0,  445,  443,  447,  447,  447,
 -        0,    0,  447,    0,    0,    0,  442,  443,  444,  448,
 -      448,  448,    0,    0,  448,  449,  449,  449,    0,    0,
 -      449,    0,  445,  450,  450,  450,    0,    0,  450,  447,
 -
 -      452,  452,  452,  444,    0,  452,    0,  445,  453,  453,
 -      453,  448,  445,  453,  454,  454,  454,  449,    0,  454,
 -        0,    0,  448,    0,    0,  450,  455,  455,  455,    0,
 -        0,  455,  452,    0,  456,  456,  456,    0,    0,  456,
 -      453,    0,  457,  457,  457,  452,  454,  457,    0,  454,
 -      458,  458,  458,    0,    0,  458,    0,    0,  455,  453,
 -        0,    0,  459,  459,  459,  455,  456,  459,  460,  460,
 -      460,    0,    0,  460,  457,    0,  461,  461,  461,    0,
 -      457,  461,  458,  456,    0,  462,  462,  462,    0,    0,
 -      462,  463,  463,  463,  459,  462,  463,  464,  464,  464,
 -
 -      460,  458,  464,  460,    0,  465,  465,  465,  461,    0,
 -      465,  459,    0,  466,  466,  466,    0,  462,  466,  467,
 -      467,  467,    0,  463,  467,    0,    0,  461,    0,  464,
 -      468,  468,  468,  464,    0,  468,  463,  465,  469,  469,
 -      469,    0,    0,  469,  465,  466,    0,  470,  470,  470,
 -        0,  467,  470,  471,  471,  471,    0,    0,  471,  472,
 -      472,  472,  468,    0,  472,    0,    0,  473,  473,  473,
 -      469,  467,  473,  476,  476,  476,    0,  469,  476,  470,
 -        0,  468,    0,    0,    0,  471,  470,  477,  477,  477,
 -        0,  472,  477,  478,  478,  478,    0,    0,  478,  473,
 -
 -        0,  479,  479,  479,  471,  476,  479,  480,  480,  480,
 -      476,  472,  480,  481,  481,  481,    0,  473,  481,  477,
 -        0,    0,  477,    0,    0,  478,  477,  483,  483,  483,
 -        0,    0,  483,  479,    0,  484,  484,  484,    0,  480,
 -      484,    0,  478,    0,    0,  481,    0,  485,  485,  485,
 -        0,  479,  485,  486,  486,  486,    0,    0,  486,  483,
 -        0,  487,  487,  487,    0,  483,  487,  484,  488,  488,
 -      488,    0,    0,  488,  484,  489,  489,  489,    0,  485,
 -      489,  490,  490,  490,    0,  486,  490,  491,  491,  491,
 -        0,    0,  491,  487,    0,    0,  492,  492,  492,  486,
 -
 -      488,  492,    0,  493,  493,  493,    0,  489,  493,    0,
 -        0,  488,    0,  490,    0,  494,  494,  494,    0,  491,
 -      494,  495,  495,  495,    0,    0,  495,    0,  492,    0,
 -      490,    0,  489,  491,    0,  493,    0,    0,    0,  492,
 -        0,  493,    0,  496,  496,  496,    0,  494,  496,  498,
 -      498,  498,    0,  495,  498,    0,  495,    0,  501,  501,
 -      501,    0,    0,  501,  502,  502,  502,    0,    0,  502,
 -        0,  503,  503,  503,    0,  496,  503,  504,  504,  504,
 -        0,  498,  504,  505,  505,  505,    0,    0,  505,  498,
 -      501,    0,    0,  501,    0,    0,  502,  506,  506,  506,
 -
 -      496,    0,  506,  503,    0,    0,    0,  506,    0,  504,
 -        0,    0,  502,    0,    0,  505,  507,  507,  507,    0,
 -        0,  507,  504,  503,    0,  508,  508,  508,    0,  506,
 -      508,    0,    0,  505,  509,  509,  509,    0,    0,  509,
 -      510,  510,  510,    0,    0,  510,    0,    0,  507,  511,
 -      511,  511,    0,    0,  511,    0,    0,  508,  512,  512,
 -      512,    0,    0,  512,    0,    0,  509,    0,    0,  513,
 -      513,  513,  510,  508,  513,  514,  514,  514,    0,  510,
 -      514,  511,  516,  516,  516,    0,  509,  516,    0,    0,
 -      512,  517,  517,  517,    0,    0,  517,  512,  511,    0,
 -
 -        0,  513,    0,  518,  518,  518,    0,  514,  518,    0,
 -        0,  519,  519,  519,  516,    0,  519,  516,    0,  513,
 -        0,  519,    0,  517,    0,  514,  520,  520,  520,    0,
 -        0,  520,  521,  521,  521,  518,    0,  521,    0,  522,
 -      522,  522,  517,  519,  522,    0,  523,  523,  523,    0,
 -        0,  523,    0,  518,  524,  524,  524,    0,  520,  524,
 -        0,    0,  519,    0,  521,    0,    0,  521,  525,  525,
 -      525,  522,    0,  525,    0,    0,    0,  520,  523,  526,
 -      526,  526,    0,    0,  526,  523,  524,  527,  527,  527,
 -        0,    0,  527,  522,  530,  530,  530,    0,    0,  530,
 -
 -      525,    0,    0,    0,  530,    0,  524,    0,  525,    0,
 -        0,  526,  531,  531,  531,    0,    0,  531,    0,  527,
 -      533,  533,  533,    0,    0,  533,  530,    0,  535,  535,
 -      535,  526,    0,  535,    0,  536,  536,  536,  527,    0,
 -      536,  537,  537,  537,  531,    0,  537,    0,  538,  538,
 -      538,    0,  533,  538,    0,    0,  539,  539,  539,  531,
 -      535,  539,    0,  540,  540,  540,  533,  536,  540,    0,
 -      542,  542,  542,  537,  535,  542,  543,  543,  543,    0,
 -      538,  543,    0,    0,  536,    0,    0,  538,  539,    0,
 -      537,  544,  544,  544,    0,  540,  544,    0,    0,    0,
 -
 -        0,    0,  542,    0,  539,  545,  545,  545,  543,    0,
 -      545,    0,  546,  546,  546,    0,  542,  546,    0,  547,
 -      547,  547,    0,  544,  547,  543,  548,  548,  548,    0,
 -      544,  548,    0,  549,  549,  549,    0,  545,  549,    0,
 -      550,  550,  550,    0,  546,  550,    0,    0,    0,  546,
 -        0,  547,  552,  552,  552,    0,  545,  552,  548,  553,
 -      553,  553,    0,    0,  553,  549,    0,    0,  554,  554,
 -      554,    0,  550,  554,  555,  555,  555,    0,  554,  555,
 -        0,  549,    0,    0,  552,  550,    0,  556,  556,  556,
 -        0,  553,  556,    0,  557,  557,  557,    0,  553,  557,
 -
 -      554,    0,  552,  558,  558,  558,  555,    0,  558,  559,
 -      559,  559,    0,    0,  559,  560,  560,  560,    0,  556,
 -      560,    0,  556,    0,  555,    0,  557,    0,    0,  557,
 -        0,  561,  561,  561,    0,  558,  561,  563,  563,  563,
 -        0,  559,  563,    0,    0,  559,    0,  560,    0,  564,
 -      564,  564,    0,    0,  564,    0,    0,  558,    0,  564,
 -      565,  565,  565,  561,    0,  565,  566,  566,  566,  563,
 -        0,  566,  567,  567,  567,    0,    0,  567,    0,    0,
 -      563,  564,  568,  568,  568,    0,    0,  568,  569,  569,
 -      569,    0,  565,  569,    0,  570,  570,  570,  566,  565,
 -
 -      570,    0,  566,    0,  567,    0,    0,  567,  571,  571,
 -      571,    0,    0,  571,  568,    0,  572,  572,  572,    0,
 -      569,  572,    0,  569,  573,  573,  573,  570,    0,  573,
 -      574,  574,  574,  568,    0,  574,  575,  575,  575,    0,
 -      571,  575,  576,  576,  576,    0,    0,  576,  572,    0,
 -        0,  571,  577,  577,  577,    0,  573,  577,  578,  578,
 -      578,    0,  574,  578,    0,  579,  579,  579,  575,  573,
 -      579,    0,    0,    0,  576,  580,  580,  580,    0,  575,
 -      580,  576,    0,    0,  577,    0,    0,  582,  582,  582,
 -      578,  577,  582,  583,  583,  583,    0,  579,  583,  584,
 -
 -      584,  584,    0,  578,  584,    0,    0,  580,  585,  585,
 -      585,    0,    0,  585,    0,  579,  586,  586,  586,  582,
 -        0,  586,  580,    0,    0,  583,  582,    0,    0,    0,
 -        0,  584,  583,  589,  589,  589,    0,    0,  589,    0,
 -      585,  590,  590,  590,    0,    0,  590,    0,  586,    0,
 -        0,  584,  591,  591,  591,    0,    0,  591,    0,  585,
 -      586,  592,  592,  592,    0,  589,  592,    0,    0,  589,
 -      593,  593,  593,  590,    0,  593,  594,  594,  594,    0,
 -      590,  594,    0,    0,  591,  595,  595,  595,    0,    0,
 -      595,    0,    0,  592,  596,  596,  596,    0,    0,  596,
 -
 -        0,    0,  593,    0,  591,  597,  597,  597,  594,    0,
 -      597,    0,    0,  593,    0,  594,    0,  595,  598,  598,
 -      598,    0,    0,  598,    0,    0,  596,  601,  601,  601,
 -        0,    0,  601,    0,    0,    0,  595,  597,    0,    0,
 -      597,  603,  603,  603,  596,    0,  603,  605,  605,  605,
 -      598,    0,  605,  598,    0,  606,  606,  606,    0,  601,
 -      606,  607,  607,  607,    0,  601,  607,  608,  608,  608,
 -        0,    0,  608,  603,    0,  609,  609,  609,  603,  605,
 -      609,  611,  611,  611,    0,    0,  611,  606,    0,    0,
 -      606,    0,    0,  607,    0,  613,  613,  613,  605,  608,
 -
 -      613,    0,    0,  615,  615,  615,  607,  609,  615,  616,
 -      616,  616,    0,  611,  616,  617,  617,  617,    0,    0,
 -      617,  618,  618,  618,    0,    0,  618,  613,    0,  611,
 -        0,  619,  619,  619,    0,  615,  619,    0,  613,    0,
 -        0,  616,    0,    0,  620,  620,  620,  617,    0,  620,
 -        0,    0,    0,  618,  620,  615,  621,  621,  621,  616,
 -        0,  621,    0,  619,  618,    0,  617,  622,  622,  622,
 -        0,    0,  622,  623,  623,  623,  620,    0,  623,  624,
 -      624,  624,    0,    0,  624,  625,  625,  625,  621,    0,
 -      625,  626,  626,  626,    0,  620,  626,    0,    0,  622,
 -
 -        0,  627,  627,  627,    0,  623,  627,  628,  628,  628,
 -        0,  624,  628,    0,    0,    0,  623,  625,  624,    0,
 -      630,  630,  630,  626,  625,  630,  626,  631,  631,  631,
 -        0,    0,  631,  627,    0,    0,  632,  632,  632,  628,
 -        0,  632,  633,  633,  633,    0,    0,  633,  627,  634,
 -      634,  634,  630,    0,  634,  635,  635,  635,  630,  631,
 -      635,  636,  636,  636,    0,    0,  636,  631,  632,    0,
 -        0,  637,  637,  637,  633,  632,  637,  638,  638,  638,
 -        0,  634,  638,    0,    0,  633,    0,  635,    0,  639,
 -      639,  639,    0,  636,  639,  640,  640,  640,    0,    0,
 -
 -      640,  634,    0,  637,    0,    0,  635,    0,    0,  638,
 -      643,  643,  643,    0,    0,  643,    0,    0,    0,  637,
 -        0,  639,    0,  644,  644,  644,    0,  640,  644,  645,
 -      645,  645,    0,    0,  645,    0,  646,  646,  646,    0,
 -      639,  646,  643,  647,  647,  647,    0,    0,  647,  648,
 -      648,  648,    0,    0,  648,  644,    0,  643,    0,    0,
 -        0,  645,    0,  644,  650,  650,  650,    0,  646,  650,
 -        0,  651,  651,  651,    0,  647,  651,  654,  654,  654,
 -        0,  648,  654,    0,  656,  656,  656,    0,  648,  656,
 -      657,  657,  657,    0,    0,  657,  650,  658,  658,  658,
 -
 -        0,    0,  658,  651,    0,    0,  659,  659,  659,  654,
 -      650,  659,  661,  661,  661,    0,  656,  661,    0,  662,
 -      662,  662,  657,  654,  662,  663,  663,  663,    0,  658,
 -      663,  664,  664,  664,    0,  656,  664,    0,  659,    0,
 -        0,    0,  657,    0,  661,  665,  665,  665,    0,  658,
 -      665,  662,    0,  666,  666,  666,    0,  663,  666,  668,
 -      668,  668,  662,  664,  668,    0,  670,  670,  670,    0,
 -      664,  670,    0,    0,    0,    0,  663,  665,  672,  672,
 -      672,    0,    0,  672,    0,  666,    0,    0,  665,    0,
 -        0,  668,  666,    0,  673,  673,  673,    0,  670,  673,
 -
 -        0,    0,  677,  677,  677,  670,  668,  677,    0,    0,
 -      672,  678,  678,  678,    0,    0,  678,  680,  680,  680,
 -        0,    0,  680,  681,  681,  681,  673,    0,  681,  672,
 -      682,  682,  682,  673,  677,  682,  683,  683,  683,    0,
 -      677,  683,    0,  678,    0,  686,  686,  686,    0,  680,
 -      686,    0,  688,  688,  688,  681,  680,  688,    0,  678,
 -        0,    0,  682,    0,  687,  687,  687,    0,  683,  687,
 -      689,  689,  689,    0,  687,  689,    0,  686,    0,  683,
 -      690,  690,  690,    0,  688,  690,    0,  691,  691,  691,
 -        0,    0,  691,  692,  692,  692,  687,    0,  692,    0,
 -
 -        0,  686,  689,  688,  693,  693,  693,    0,    0,  693,
 -        0,    0,  690,    0,    0,  694,  694,  694,  689,  691,
 -      694,  695,  695,  695,    0,  692,  695,  691,  696,  696,
 -      696,  695,    0,  696,    0,    0,  693,  697,  697,  697,
 -        0,    0,  697,  700,  700,  700,    0,  694,  700,  701,
 -      701,  701,    0,  695,  701,    0,  702,  702,  702,  701,
 -      696,  702,    0,  703,  703,  703,  696,  694,  703,  697,
 -        0,  704,  704,  704,    0,  700,  704,  706,  706,  706,
 -        0,  701,  706,    0,  709,  709,  709,    0,  702,  709,
 -        0,  700,  710,  710,  710,  703,    0,  710,    0,  711,
 -
 -      711,  711,    0,  704,  711,  702,    0,    0,    0,  706,
 -      713,  713,  713,    0,    0,  713,  709,    0,  704,    0,
 -      706,  715,  715,  715,  710,    0,  715,  709,  716,  716,
 -      716,  711,    0,  716,    0,    0,    0,    0,  711,    0,
 -      710,    0,  713,    0,  718,  718,  718,    0,    0,  718,
 -      719,  719,  719,  715,  718,  719,    0,  713,    0,    0,
 -      716,    0,  720,  720,  720,    0,  715,  720,  721,  721,
 -      721,    0,    0,  721,    0,    0,  718,    0,  716,  722,
 -      722,  722,  719,    0,  722,    0,    0,  723,  723,  723,
 -        0,  719,  723,    0,  720,    0,    0,  723,    0,    0,
 -
 -      721,  724,  724,  724,    0,    0,  724,    0,  720,    0,
 -        0,  722,    0,  725,  725,  725,    0,  721,  725,  723,
 -      726,  726,  726,    0,    0,  726,  727,  727,  727,    0,
 -        0,  727,    0,  724,  728,  728,  728,    0,    0,  728,
 -      724,    0,  729,  729,  729,  725,    0,  729,  731,  731,
 -      731,    0,  726,  731,  732,  732,  732,    0,  727,  732,
 -        0,  725,    0,  726,    0,    0,  728,  733,  733,  733,
 -        0,    0,  733,  728,  729,    0,  734,  734,  734,    0,
 -      731,  734,    0,  736,  736,  736,  732,    0,  736,    0,
 -      737,  737,  737,    0,  729,  737,    0,  731,    0,  733,
 -
 -        0,  732,    0,    0,  733,  738,  738,  738,  734,    0,
 -      738,  739,  739,  739,  734,  736,  739,    0,  740,  740,
 -      740,    0,  737,  740,  741,  741,  741,    0,    0,  741,
 -      743,  743,  743,  737,    0,  743,    0,  738,    0,    0,
 -      744,  744,  744,  739,  738,  744,    0,  746,  746,  746,
 -      740,    0,  746,  747,  747,  747,  741,  740,  747,  748,
 -      748,  748,  743,  741,  748,  749,  749,  749,    0,    0,
 -      749,    0,  744,    0,    0,  750,  750,  750,  743,  746,
 -      750,  751,  751,  751,    0,  747,  751,  752,  752,  752,
 -      744,  748,  752,    0,    0,    0,    0,  749,  746,    0,
 -
 -      747,    0,    0,    0,    0,    0,  748,  750,  749,  753,
 -      753,  753,    0,  751,  753,  754,  754,  754,    0,  752,
 -      754,    0,  755,  755,  755,    0,  750,  755,    0,  756,
 -      756,  756,    0,  751,  756,  757,  757,  757,  752,    0,
 -      757,  753,    0,  758,  758,  758,    0,  754,  758,    0,
 -        0,  759,  759,  759,  755,    0,  759,  753,  754,    0,
 -        0,  756,    0,    0,    0,  755,    0,  757,    0,  761,
 -      761,  761,    0,  757,  761,  758,  762,  762,  762,    0,
 -        0,  762,    0,  759,  763,  763,  763,    0,    0,  763,
 -      758,  759,  765,  765,  765,    0,    0,  765,  766,  766,
 -
 -      766,  761,    0,  766,  768,  768,  768,    0,  762,  768,
 -      769,  769,  769,    0,    0,  769,  763,  762,  770,  770,
 -      770,    0,    0,  770,  765,    0,    0,  763,    0,    0,
 -      766,    0,    0,    0,    0,    0,  768,  766,    0,    0,
 -        0,    0,  769,    0,    0,    0,    0,    0,    0,    0,
 -      770,    0,    0,    0,  768,    0,    0,    0,    0,    0,
 -        0,  769,  773,  773,  773,  773,  773,  773,  773,  774,
 -      774,  774,  774,  774,  774,  774,  775,    0,  775,  775,
 -      775,  775,  775,  776,    0,  776,    0,  776,  776,  776,
 -      777,  777,  777,  777,  777,  777,  777,  778,  778,  778,
 -
 -      778,  778,  778,  778,  779,    0,  779,  779,  779,  779,
 -      779,  780,  780,    0,  780,  781,  781,  781,  781,  781,
 -      782,  782,  783,  783,  784,  784,  785,  785,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772,  772,
 -      772,  772,  772,  772,  772,  772,  772,  772,  772
--    } ;
--
--static yy_state_type yy_last_accepting_state;
--static char *yy_last_accepting_cpos;
--
--extern int parser6__flex_debug;
--int parser6__flex_debug = 1;
--
- static yyconst flex_int16_t yy_rule_linenum[106] =
 -static yyconst flex_int16_t yy_rule_linenum[109] =
--    {   0,
--      130,  132,  134,  139,  140,  145,  146,  147,  159,  162,
--      167,  174,  183,  192,  201,  210,  219,  228,  240,  250,
--      260,  270,  281,  291,  301,  311,  321,  331,  340,  349,
--      358,  373,  388,  397,  406,  415,  424,  433,  442,  451,
--      460,  469,  478,  487,  496,  505,  514,  523,  533,  542,
--      551,  560,  569,  578,  587,  596,  605,  614,  624,  634,
--      644,  653,  662,  671,  682,  692,  701,  711,  720,  729,
--      738,  747,  756,  765,  775,  784,  793,  802,  811,  820,
--      829,  838,  847,  856,  865,  874,  883,  892,  901,  910,
-       919,  982,  987,  992,  997,  998,  999, 1000, 1001, 1002,
 -      919, 1017, 1022, 1027, 1032, 1033, 1034, 1035, 1036, 1037,
--
-      1004, 1022, 1035, 1040, 1044
 -     1039, 1057, 1070, 1075, 1079, 1081, 1083, 1085
--    } ;
--
--/* The intent behind this definition is that it'll catch
-- * any uses of REJECT which flex missed.
-- */
--#define REJECT reject_used_but_not_detected
--#define yymore() yymore_used_but_not_detected
--#define YY_MORE_ADJ 0
--#define YY_RESTORE_YY_MORE_OFFSET
--char *parser6_text;
--#line 1 "dhcp6_lexer.ll"
- /* Copyright (C) 2016 Internet Systems Consortium, Inc. ("ISC")
 -/* Copyright (C) 2015-2016 Internet Systems Consortium, Inc. ("ISC")
--
--   This Source Code Form is subject to the terms of the Mozilla Public
--   License, v. 2.0. If a copy of the MPL was not distributed with this
--   file, You can obtain one at http://mozilla.org/MPL/2.0/. */
--#line 8 "dhcp6_lexer.ll"
--#include <cerrno>
--#include <climits>
--#include <cstdlib>
--#include <string>
--#include <dhcp6/parser_context.h>
--#include <asiolink/io_address.h>
--#include <boost/lexical_cast.hpp>
--#include <exceptions/exceptions.h>
--
--// Work around an incompatibility in flex (at least versions
--// 2.5.31 through 2.5.33): it generates code that does
--// not conform to C89.  See Debian bug 333231
--// <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>.
--# undef parser6_wrap
--# define parser6_wrap() 1
--
--namespace {
--
--bool start_token_flag = false;
--
--isc::dhcp::Parser6Context::ParserType start_token_value;
--unsigned int comment_start_line = 0;
--
--};
--
--// To avoid the call to exit... oops!
--#define YY_FATAL_ERROR(msg) isc::dhcp::Parser6Context::fatal(msg)
--/* noyywrap disables automatic rewinding for the next file to parse. Since we
--   always parse only a single string, there's no need to do any wraps. And
--   using parser6_wrap requires linking with -lfl, which provides the default parser6_wrap
--   implementation that always returns 1 anyway. */
--/* nounput simplifies the lexer, by removing support for putting a character
--   back into the input stream. We never use such capability anyway. */
--/* batch means that we'll never use the generated lexer interactively. */
--/* avoid to get static global variables to remain with C++. */
--/* in last resort %option reentrant */
--/* Enables debug mode. To see the debug messages, one needs to also set
--   parser6__flex_debug to 1, then the debug messages will be printed on stderr. */
--/* I have no idea what this option does, except it was specified in the bison
--   examples and Postgres folks added it to remove gcc 4.3 warnings. Let's
--   be on the safe side and keep it. */
--#define YY_NO_INPUT 1
--
--
--/* These are not token expressions yet, just convenience expressions that
--   can be used during actual token definitions. Note some can match
--   incorrect inputs (e.g., IP addresses) which must be checked. */
--/* for errors */
--#line 86 "dhcp6_lexer.ll"
--// This code run each time a pattern is matched. It updates the location
--// by moving it ahead by parser6_leng bytes. parser6_leng specifies the length of the
--// currently matched token.
--#define YY_USER_ACTION  driver.loc_.columns(parser6_leng);
- #line 1134 "dhcp6_lexer.cc"
 -#line 2139 "dhcp6_lexer.cc"
--
--#define INITIAL 0
--#define COMMENT 1
--#define DIR_ENTER 2
--#define DIR_INCLUDE 3
--#define DIR_EXIT 4
--
--#ifndef YY_NO_UNISTD_H
--/* Special case for "unistd.h", since it is non-ANSI. We include it way
-- * down here because we want the user's section 1 to have been scanned first.
-- * The user has a chance to override it with an option.
-- */
--/* %if-c-only */
--#include <unistd.h>
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--#endif
--
--#ifndef YY_EXTRA_TYPE
--#define YY_EXTRA_TYPE void *
--#endif
--
--/* %if-c-only Reentrant structure and macros (non-C++). */
--/* %if-reentrant */
--/* %if-c-only */
--
--static int yy_init_globals (void );
--
--/* %endif */
--/* %if-reentrant */
--/* %endif */
--/* %endif End reentrant structures and macros. */
--
--/* Accessor methods to globals.
--   These are made visible to non-reentrant scanners for convenience. */
--
--int parser6_lex_destroy (void );
--
--int parser6_get_debug (void );
--
--void parser6_set_debug (int debug_flag  );
--
--YY_EXTRA_TYPE parser6_get_extra (void );
--
--void parser6_set_extra (YY_EXTRA_TYPE user_defined  );
--
--FILE *parser6_get_in (void );
--
--void parser6_set_in  (FILE * _in_str  );
--
--FILE *parser6_get_out (void );
--
--void parser6_set_out  (FILE * _out_str  );
--
- yy_size_t parser6_get_leng (void );
 -                      int parser6_get_leng (void );
--
--char *parser6_get_text (void );
--
--int parser6_get_lineno (void );
--
--void parser6_set_lineno (int _line_number  );
--
--/* %if-bison-bridge */
--/* %endif */
--
--/* Macros after this point can all be overridden by user definitions in
-- * section 1.
-- */
--
--#ifndef YY_SKIP_YYWRAP
--#ifdef __cplusplus
--extern "C" int parser6_wrap (void );
--#else
--extern int parser6_wrap (void );
--#endif
--#endif
--
--/* %not-for-header */
--
--#ifndef YY_NO_UNPUT
--    
--#endif
--/* %ok-for-header */
--
--/* %endif */
--
--#ifndef yytext_ptr
--static void yy_flex_strncpy (char *,yyconst char *,int );
--#endif
--
--#ifdef YY_NEED_STRLEN
--static int yy_flex_strlen (yyconst char * );
--#endif
--
--#ifndef YY_NO_INPUT
--/* %if-c-only Standard (non-C++) definition */
--/* %not-for-header */
--
--#ifdef __cplusplus
--static int yyinput (void );
--#else
--static int input (void );
--#endif
--/* %ok-for-header */
--
--/* %endif */
--#endif
--
--/* %if-c-only */
--
--/* %endif */
--
--/* Amount of stuff to slurp up with each read. */
--#ifndef YY_READ_BUF_SIZE
--#ifdef __ia64__
--/* On IA-64, the buffer size is 16k, not 8k */
--#define YY_READ_BUF_SIZE 16384
--#else
--#define YY_READ_BUF_SIZE 8192
--#endif /* __ia64__ */
--#endif
--
--/* Copy whatever the last rule matched to the standard output. */
--#ifndef ECHO
--/* %if-c-only Standard (non-C++) definition */
--/* This used to be an fputs(), but since the string might contain NUL's,
-- * we now use fwrite().
-- */
- #define ECHO do { if (fwrite( parser6_text, parser6_leng, 1, parser6_out )) {} } while (0)
 -#define ECHO do { if (fwrite( parser6_text, (size_t) parser6_leng, 1, parser6_out )) {} } while (0)
--/* %endif */
--/* %if-c++-only C++ definition */
--/* %endif */
--#endif
--
--/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
-- * is returned in "result".
-- */
--#ifndef YY_INPUT
--#define YY_INPUT(buf,result,max_size) \
--/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
--      if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
--              { \
--              int c = '*'; \
--              size_t n; \
--              for ( n = 0; n < max_size && \
--                           (c = getc( parser6_in )) != EOF && c != '\n'; ++n ) \
--                      buf[n] = (char) c; \
--              if ( c == '\n' ) \
--                      buf[n++] = (char) c; \
--              if ( c == EOF && ferror( parser6_in ) ) \
--                      YY_FATAL_ERROR( "input in flex scanner failed" ); \
--              result = n; \
--              } \
--      else \
--              { \
--              errno=0; \
-               while ( (result = fread(buf, 1, max_size, parser6_in))==0 && ferror(parser6_in)) \
 -              while ( (result = (int) fread(buf, 1, max_size, parser6_in))==0 && ferror(parser6_in)) \
--                      { \
--                      if( errno != EINTR) \
--                              { \
--                              YY_FATAL_ERROR( "input in flex scanner failed" ); \
--                              break; \
--                              } \
--                      errno=0; \
--                      clearerr(parser6_in); \
--                      } \
--              }\
--\
--/* %if-c++-only C++ definition \ */\
--/* %endif */
--
--#endif
--
--/* No semi-colon after return; correct usage is to write "yyterminate();" -
-- * we don't want an extra ';' after the "return" because that will cause
-- * some compilers to complain about unreachable statements.
-- */
--#ifndef yyterminate
--#define yyterminate() return YY_NULL
--#endif
--
--/* Number of entries by which start-condition stack grows. */
--#ifndef YY_START_STACK_INCR
--#define YY_START_STACK_INCR 25
--#endif
--
--/* Report a fatal error. */
--#ifndef YY_FATAL_ERROR
--/* %if-c-only */
--#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--#endif
--
--/* %if-tables-serialization structures and prototypes */
--/* %not-for-header */
--
--/* %ok-for-header */
--
--/* %not-for-header */
--
--/* %tables-yydmap generated elements */
--/* %endif */
--/* end tables serialization structures and prototypes */
--
--/* %ok-for-header */
--
--/* Default declaration of generated scanner - a define so the user can
-- * easily add parameters.
-- */
--#ifndef YY_DECL
--#define YY_DECL_IS_OURS 1
--/* %if-c-only Standard (non-C++) definition */
--
--extern int parser6_lex (void);
--
--#define YY_DECL int parser6_lex (void)
--/* %endif */
--/* %if-c++-only C++ definition */
--/* %endif */
--#endif /* !YY_DECL */
--
--/* Code executed at the beginning of each rule, after parser6_text and parser6_leng
-- * have been set up.
-- */
--#ifndef YY_USER_ACTION
--#define YY_USER_ACTION
--#endif
--
--/* Code executed at the end of each rule. */
--#ifndef YY_BREAK
--#define YY_BREAK /*LINTED*/break;
--#endif
--
--/* %% [6.0] YY_RULE_SETUP definition goes here */
--#define YY_RULE_SETUP \
--      YY_USER_ACTION
--
--/* %not-for-header */
--
--/** The main scanner function which does all the work.
-- */
--YY_DECL
--{
--      yy_state_type yy_current_state;
--      char *yy_cp, *yy_bp;
--      int yy_act;
--    
--      if ( !(yy_init) )
--              {
--              (yy_init) = 1;
--
--#ifdef YY_USER_INIT
--              YY_USER_INIT;
--#endif
--
--              if ( ! (yy_start) )
--                      (yy_start) = 1; /* first start state */
--
--              if ( ! parser6_in )
--/* %if-c-only */
--                      parser6_in = stdin;
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--
--              if ( ! parser6_out )
--/* %if-c-only */
--                      parser6_out = stdout;
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--
--              if ( ! YY_CURRENT_BUFFER ) {
--                      parser6_ensure_buffer_stack ();
--                      YY_CURRENT_BUFFER_LVALUE =
--                              parser6__create_buffer(parser6_in,YY_BUF_SIZE );
--              }
--
--              parser6__load_buffer_state( );
--              }
--
--      {
--/* %% [7.0] user's declarations go here */
--#line 92 "dhcp6_lexer.ll"
--
--
--
--    // This part of the code is copied over to the verbatim to the top
--    // of the generated parser6_lex function. Explanation:
--    // http://www.gnu.org/software/bison/manual/html_node/Multiple-start_002dsymbols.html
--
--    // Code run each time parser6_lex is called.
--    driver.loc_.step();
--
--    if (start_token_flag) {
--        start_token_flag = false;
--        switch (start_token_value) {
--        case Parser6Context::PARSER_JSON:
--        default:
--            return isc::dhcp::Dhcp6Parser::make_TOPLEVEL_JSON(driver.loc_);
--        case Parser6Context::PARSER_DHCP6:
--            return isc::dhcp::Dhcp6Parser::make_TOPLEVEL_DHCP6(driver.loc_);
--        case Parser6Context::SUBPARSER_DHCP6:
--            return isc::dhcp::Dhcp6Parser::make_SUB_DHCP6(driver.loc_);
--        case Parser6Context::PARSER_INTERFACES:
--            return isc::dhcp::Dhcp6Parser::make_SUB_INTERFACES6(driver.loc_);
--        case Parser6Context::PARSER_SUBNET6:
--            return isc::dhcp::Dhcp6Parser::make_SUB_SUBNET6(driver.loc_);
--        case Parser6Context::PARSER_POOL6:
--            return isc::dhcp::Dhcp6Parser::make_SUB_POOL6(driver.loc_);
--        case Parser6Context::PARSER_PD_POOL:
--            return isc::dhcp::Dhcp6Parser::make_SUB_PD_POOL(driver.loc_);
--        case Parser6Context::PARSER_HOST_RESERVATION:
--            return isc::dhcp::Dhcp6Parser::make_SUB_RESERVATION(driver.loc_);
--        case Parser6Context::PARSER_OPTION_DATA:
--            return isc::dhcp::Dhcp6Parser::make_SUB_OPTION_DATA(driver.loc_);
--        case Parser6Context::PARSER_HOOKS_LIBRARY:
--            return isc::dhcp::Dhcp6Parser::make_SUB_HOOKS_LIBRARY(driver.loc_);
--        }
--    }
--
--
- #line 1460 "dhcp6_lexer.cc"
 -#line 2465 "dhcp6_lexer.cc"
--
--      while ( /*CONSTCOND*/1 )                /* loops until end-of-file is reached */
--              {
--/* %% [8.0] yymore()-related code goes here */
--              yy_cp = (yy_c_buf_p);
--
--              /* Support of parser6_text. */
--              *yy_cp = (yy_hold_char);
--
--              /* yy_bp points to the position in yy_ch_buf of the start of
--               * the current run.
--               */
--              yy_bp = yy_cp;
--
--/* %% [9.0] code to set up and find next match goes here */
--              yy_current_state = (yy_start);
--yy_match:
--              do
--                      {
--                      YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
--                      if ( yy_accept[yy_current_state] )
--                              {
--                              (yy_last_accepting_state) = yy_current_state;
--                              (yy_last_accepting_cpos) = yy_cp;
--                              }
--                      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
--                              {
--                              yy_current_state = (int) yy_def[yy_current_state];
-                               if ( yy_current_state >= 759 )
 -                              if ( yy_current_state >= 773 )
--                                      yy_c = yy_meta[(unsigned int) yy_c];
--                              }
-                       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 -                      yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
--                      ++yy_cp;
--                      }
-               while ( yy_current_state != 758 );
 -              while ( yy_current_state != 772 );
--              yy_cp = (yy_last_accepting_cpos);
--              yy_current_state = (yy_last_accepting_state);
--
--yy_find_action:
--/* %% [10.0] code to find the action number goes here */
--              yy_act = yy_accept[yy_current_state];
--
--              YY_DO_BEFORE_ACTION;
--
--/* %% [11.0] code for parser6_lineno update goes here */
--
--do_action:    /* This label is used only to access EOF actions. */
--
--/* %% [12.0] debug code goes here */
--              if ( parser6__flex_debug )
--                      {
--                      if ( yy_act == 0 )
--                              fprintf( stderr, "--scanner backing up\n" );
-                       else if ( yy_act < 106 )
 -                      else if ( yy_act < 109 )
--                              fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n",
--                                       (long)yy_rule_linenum[yy_act], parser6_text );
-                       else if ( yy_act == 106 )
 -                      else if ( yy_act == 109 )
--                              fprintf( stderr, "--accepting default rule (\"%s\")\n",
--                                       parser6_text );
-                       else if ( yy_act == 107 )
 -                      else if ( yy_act == 110 )
--                              fprintf( stderr, "--(end of buffer or a NUL)\n" );
--                      else
--                              fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
--                      }
--
--              switch ( yy_act )
--      { /* beginning of action switch */
--/* %% [13.0] actions go here */
--                      case 0: /* must back up */
--                      /* undo the effects of YY_DO_BEFORE_ACTION */
--                      *yy_cp = (yy_hold_char);
--                      yy_cp = (yy_last_accepting_cpos);
--                      yy_current_state = (yy_last_accepting_state);
--                      goto yy_find_action;
--
--case 1:
--YY_RULE_SETUP
--#line 130 "dhcp6_lexer.ll"
--;
--      YY_BREAK
--case 2:
--YY_RULE_SETUP
--#line 132 "dhcp6_lexer.ll"
--;
--      YY_BREAK
--case 3:
--YY_RULE_SETUP
--#line 134 "dhcp6_lexer.ll"
--{
--  BEGIN(COMMENT);
--  comment_start_line = driver.loc_.end.line;;
--}
--      YY_BREAK
--case 4:
--YY_RULE_SETUP
--#line 139 "dhcp6_lexer.ll"
--BEGIN(INITIAL);
--      YY_BREAK
--case 5:
--YY_RULE_SETUP
--#line 140 "dhcp6_lexer.ll"
--;
--      YY_BREAK
--case YY_STATE_EOF(COMMENT):
--#line 141 "dhcp6_lexer.ll"
--{
--    isc_throw(Dhcp6ParseError, "Comment not closed. (/* in line " << comment_start_line);
--}
--      YY_BREAK
--case 6:
--YY_RULE_SETUP
--#line 145 "dhcp6_lexer.ll"
--BEGIN(DIR_ENTER);
--      YY_BREAK
--case 7:
--YY_RULE_SETUP
--#line 146 "dhcp6_lexer.ll"
--BEGIN(DIR_INCLUDE);
--      YY_BREAK
--case 8:
--YY_RULE_SETUP
--#line 147 "dhcp6_lexer.ll"
--{
--    // Include directive.
--
--    // Extract the filename.
--    std::string tmp(parser6_text+1);
--    tmp.resize(tmp.size() - 1);
--
--    driver.includeFile(tmp);
--}
--      YY_BREAK
--case YY_STATE_EOF(DIR_ENTER):
--case YY_STATE_EOF(DIR_INCLUDE):
--case YY_STATE_EOF(DIR_EXIT):
--#line 156 "dhcp6_lexer.ll"
--{
--    isc_throw(Dhcp6ParseError, "Directive not closed.");
--}
--      YY_BREAK
--case 9:
--YY_RULE_SETUP
--#line 159 "dhcp6_lexer.ll"
--BEGIN(INITIAL);
--      YY_BREAK
--case 10:
--YY_RULE_SETUP
--#line 162 "dhcp6_lexer.ll"
--{
--    // Ok, we found a with space. Let's ignore it and update loc variable.
--    driver.loc_.step();
--}
--      YY_BREAK
--case 11:
--/* rule 11 can match eol */
--YY_RULE_SETUP
--#line 167 "dhcp6_lexer.ll"
--{
--    // Newline found. Let's update the location and continue.
--    driver.loc_.lines(parser6_leng);
--    driver.loc_.step();
--}
--      YY_BREAK
--case 12:
--YY_RULE_SETUP
--#line 174 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CONFIG:
--        return isc::dhcp::Dhcp6Parser::make_DHCP6(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("Dhcp6", driver.loc_);
--    }
--}
--      YY_BREAK
--case 13:
--YY_RULE_SETUP
--#line 183 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return  isc::dhcp::Dhcp6Parser::make_INTERFACES_CONFIG(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("interfaces-config", driver.loc_);
--    }
--}
--      YY_BREAK
--case 14:
--YY_RULE_SETUP
--#line 192 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::INTERFACES_CONFIG:
--        return  isc::dhcp::Dhcp6Parser::make_INTERFACES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("interfaces", driver.loc_);
--    }
--}
--      YY_BREAK
--case 15:
--YY_RULE_SETUP
--#line 201 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_LEASE_DATABASE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("lease-database", driver.loc_);
--    }
--}
--      YY_BREAK
--case 16:
--YY_RULE_SETUP
--#line 210 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_HOSTS_DATABASE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("hosts-database", driver.loc_);
--    }
--}
--      YY_BREAK
--case 17:
--YY_RULE_SETUP
--#line 219 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--        return isc::dhcp::Dhcp6Parser::make_READONLY(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("readonly", driver.loc_);
--    }
--}
--      YY_BREAK
--case 18:
--YY_RULE_SETUP
--#line 228 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--    case isc::dhcp::Parser6Context::SERVER_ID:
--        return isc::dhcp::Dhcp6Parser::make_TYPE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("type", driver.loc_);
--    }
--}
--      YY_BREAK
--case 19:
--YY_RULE_SETUP
--#line 240 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--        return isc::dhcp::Dhcp6Parser::make_USER(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("user", driver.loc_);
--    }
--}
--      YY_BREAK
--case 20:
--YY_RULE_SETUP
--#line 250 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--        return isc::dhcp::Dhcp6Parser::make_PASSWORD(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("password", driver.loc_);
--    }
--}
--      YY_BREAK
--case 21:
--YY_RULE_SETUP
--#line 260 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--        return isc::dhcp::Dhcp6Parser::make_HOST(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("host", driver.loc_);
--    }
--}
--      YY_BREAK
--case 22:
--YY_RULE_SETUP
--#line 270 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--    case isc::dhcp::Parser6Context::SERVER_ID:
--        return isc::dhcp::Dhcp6Parser::make_PERSIST(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("persist", driver.loc_);
--    }
--}
--      YY_BREAK
--case 23:
--YY_RULE_SETUP
--#line 281 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--        return isc::dhcp::Dhcp6Parser::make_LFC_INTERVAL(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("lfc-interval", driver.loc_);
--    }
--}
--      YY_BREAK
--case 24:
--YY_RULE_SETUP
--#line 291 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_PREFERRED_LIFETIME(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("preferred-lifetime", driver.loc_);
--    }
--}
--      YY_BREAK
--case 25:
--YY_RULE_SETUP
--#line 301 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_VALID_LIFETIME(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("valid-lifetime", driver.loc_);
--    }
--}
--      YY_BREAK
--case 26:
--YY_RULE_SETUP
--#line 311 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_RENEW_TIMER(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("renew-timer", driver.loc_);
--    }
--}
--      YY_BREAK
--case 27:
--YY_RULE_SETUP
--#line 321 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_REBIND_TIMER(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("rebind-timer", driver.loc_);
--    }
--}
--      YY_BREAK
--case 28:
--YY_RULE_SETUP
--#line 331 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_DECLINE_PROBATION_PERIOD(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("decline-probation-period", driver.loc_);
--    }
--}
--      YY_BREAK
--case 29:
--YY_RULE_SETUP
--#line 340 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_SUBNET6(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("subnet6", driver.loc_);
--    }
--}
--      YY_BREAK
--case 30:
--YY_RULE_SETUP
--#line 349 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_OPTION_DEF(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("option-def", driver.loc_);
--    }
--}
--      YY_BREAK
--case 31:
--YY_RULE_SETUP
--#line 358 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--    case isc::dhcp::Parser6Context::SUBNET6:
--    case isc::dhcp::Parser6Context::POOLS:
--    case isc::dhcp::Parser6Context::PD_POOLS:
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
--    case isc::dhcp::Parser6Context::CLIENT_CLASS:
--        return isc::dhcp::Dhcp6Parser::make_OPTION_DATA(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("option-data", driver.loc_);
--    }
--}
--      YY_BREAK
--case 32:
--YY_RULE_SETUP
--#line 373 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LEASE_DATABASE:
--    case isc::dhcp::Parser6Context::HOSTS_DATABASE:
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--    case isc::dhcp::Parser6Context::OPTION_DATA:
--    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
--    case isc::dhcp::Parser6Context::CLIENT_CLASS:
--    case isc::dhcp::Parser6Context::LOGGERS:
--        return isc::dhcp::Dhcp6Parser::make_NAME(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("name", driver.loc_);
--    }
--}
--      YY_BREAK
--case 33:
--YY_RULE_SETUP
--#line 388 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DATA:
--        return isc::dhcp::Dhcp6Parser::make_DATA(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("data", driver.loc_);
--    }
--}
--      YY_BREAK
--case 34:
--YY_RULE_SETUP
--#line 397 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_POOLS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("pools", driver.loc_);
--    }
--}
--      YY_BREAK
--case 35:
--YY_RULE_SETUP
--#line 406 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_PD_POOLS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("pd-pools", driver.loc_);
--    }
--}
--      YY_BREAK
--case 36:
--YY_RULE_SETUP
--#line 415 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::PD_POOLS:
--        return isc::dhcp::Dhcp6Parser::make_PREFIX(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("prefix", driver.loc_);
--    }
--}
--      YY_BREAK
--case 37:
--YY_RULE_SETUP
--#line 424 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::PD_POOLS:
--        return isc::dhcp::Dhcp6Parser::make_PREFIX_LEN(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("prefix-len", driver.loc_);
--    }
--}
--      YY_BREAK
--case 38:
--YY_RULE_SETUP
--#line 433 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::PD_POOLS:
--        return isc::dhcp::Dhcp6Parser::make_EXCLUDED_PREFIX(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("excluded-prefix", driver.loc_);
--    }
--}
--      YY_BREAK
--case 39:
--YY_RULE_SETUP
--#line 442 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::PD_POOLS:
--        return isc::dhcp::Dhcp6Parser::make_EXCLUDED_PREFIX_LEN(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("excluded-prefix-len", driver.loc_);
--    }
--}
--      YY_BREAK
--case 40:
--YY_RULE_SETUP
--#line 451 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::PD_POOLS:
--        return isc::dhcp::Dhcp6Parser::make_DELEGATED_LEN(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("delegated-len", driver.loc_);
--    }
--}
--      YY_BREAK
--case 41:
--YY_RULE_SETUP
--#line 460 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::POOLS:
--        return isc::dhcp::Dhcp6Parser::make_POOL(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("pool", driver.loc_);
--    }
--}
--      YY_BREAK
--case 42:
--YY_RULE_SETUP
--#line 469 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_SUBNET(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("subnet", driver.loc_);
--    }
--}
--      YY_BREAK
--case 43:
--YY_RULE_SETUP
--#line 478 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_INTERFACE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("interface", driver.loc_);
--    }
--}
--      YY_BREAK
--case 44:
--YY_RULE_SETUP
--#line 487 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_INTERFACE_ID(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("interface-id", driver.loc_);
--    }
--}
--      YY_BREAK
--case 45:
--YY_RULE_SETUP
--#line 496 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_ID(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("id", driver.loc_);
--    }
--}
--      YY_BREAK
--case 46:
--YY_RULE_SETUP
--#line 505 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_RAPID_COMMIT(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("rapid-commit", driver.loc_);
--    }
--}
--      YY_BREAK
--case 47:
--YY_RULE_SETUP
--#line 514 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_RESERVATION_MODE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("reservation-mode", driver.loc_);
--    }
--}
--      YY_BREAK
--case 48:
--YY_RULE_SETUP
--#line 523 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--    case isc::dhcp::Parser6Context::OPTION_DATA:
--        return isc::dhcp::Dhcp6Parser::make_CODE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("code", driver.loc_);
--    }
--}
--      YY_BREAK
--case 49:
--YY_RULE_SETUP
--#line 533 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_MAC_SOURCES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("mac-sources", driver.loc_);
--    }
--}
--      YY_BREAK
--case 50:
--YY_RULE_SETUP
--#line 542 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_RELAY_SUPPLIED_OPTIONS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("relay-supplied-options", driver.loc_);
--    }
--}
--      YY_BREAK
--case 51:
--YY_RULE_SETUP
--#line 551 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_HOST_RESERVATION_IDENTIFIERS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("host-reservation-identifiers", driver.loc_);
--    }
--}
--      YY_BREAK
--case 52:
--YY_RULE_SETUP
--#line 560 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CONFIG:
--        return isc::dhcp::Dhcp6Parser::make_LOGGING(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("Logging", driver.loc_);
--    }
--}
--      YY_BREAK
--case 53:
--YY_RULE_SETUP
--#line 569 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LOGGING:
--        return isc::dhcp::Dhcp6Parser::make_LOGGERS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("loggers", driver.loc_);
--    }
--}
--      YY_BREAK
--case 54:
--YY_RULE_SETUP
--#line 578 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LOGGERS:
--        return isc::dhcp::Dhcp6Parser::make_OUTPUT_OPTIONS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("output_options", driver.loc_);
--    }
--}
--      YY_BREAK
--case 55:
--YY_RULE_SETUP
--#line 587 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OUTPUT_OPTIONS:
--        return isc::dhcp::Dhcp6Parser::make_OUTPUT(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("output", driver.loc_);
--    }
--}
--      YY_BREAK
--case 56:
--YY_RULE_SETUP
--#line 596 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LOGGERS:
--        return isc::dhcp::Dhcp6Parser::make_DEBUGLEVEL(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("debuglevel", driver.loc_);
--    }
--}
--      YY_BREAK
--case 57:
--YY_RULE_SETUP
--#line 605 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::LOGGERS:
--        return isc::dhcp::Dhcp6Parser::make_SEVERITY(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("severity", driver.loc_);
--    }
--}
--      YY_BREAK
--case 58:
--YY_RULE_SETUP
--#line 614 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--        return isc::dhcp::Dhcp6Parser::make_CLIENT_CLASSES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("client-classes", driver.loc_);
--    }
--}
--      YY_BREAK
--case 59:
--YY_RULE_SETUP
--#line 624 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
--        return isc::dhcp::Dhcp6Parser::make_CLIENT_CLASS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("client-class", driver.loc_);
--    }
--}
--      YY_BREAK
--case 60:
--YY_RULE_SETUP
--#line 634 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CLIENT_CLASSES:
--    case isc::dhcp::Parser6Context::CLIENT_CLASS:
--        return isc::dhcp::Dhcp6Parser::make_TEST(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("test", driver.loc_);
--    }
--}
--      YY_BREAK
--case 61:
--YY_RULE_SETUP
--#line 644 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_RESERVATIONS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("reservations", driver.loc_);
--    }
--}
--      YY_BREAK
--case 62:
--YY_RULE_SETUP
--#line 653 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--        return isc::dhcp::Dhcp6Parser::make_IP_ADDRESSES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("ip-addresses", driver.loc_);
--    }
--}
--      YY_BREAK
--case 63:
--YY_RULE_SETUP
--#line 662 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--        return isc::dhcp::Dhcp6Parser::make_PREFIXES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("prefixes", driver.loc_);
--    }
--}
--      YY_BREAK
--case 64:
--YY_RULE_SETUP
--#line 671 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::MAC_SOURCES:
--    case isc::dhcp::Parser6Context::HOST_RESERVATION_IDENTIFIERS:
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--        return isc::dhcp::Dhcp6Parser::make_DUID(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("duid", driver.loc_);
--    }
--}
--      YY_BREAK
--case 65:
--YY_RULE_SETUP
--#line 682 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::HOST_RESERVATION_IDENTIFIERS:
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--        return isc::dhcp::Dhcp6Parser::make_HW_ADDRESS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("hw-address", driver.loc_);
--    }
--}
--      YY_BREAK
--case 66:
--YY_RULE_SETUP
--#line 692 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::RESERVATIONS:
--        return isc::dhcp::Dhcp6Parser::make_HOSTNAME(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("hostname", driver.loc_);
--    }
--}
--      YY_BREAK
--case 67:
--YY_RULE_SETUP
--#line 701 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--    case isc::dhcp::Parser6Context::OPTION_DATA:
--        return isc::dhcp::Dhcp6Parser::make_SPACE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("space", driver.loc_);
--    }
--}
--      YY_BREAK
--case 68:
--YY_RULE_SETUP
--#line 711 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DATA:
--        return isc::dhcp::Dhcp6Parser::make_CSV_FORMAT(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("csv-format", driver.loc_);
--    }
--}
--      YY_BREAK
--case 69:
--YY_RULE_SETUP
--#line 720 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--        return isc::dhcp::Dhcp6Parser::make_RECORD_TYPES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("record-types", driver.loc_);
--    }
--}
--      YY_BREAK
--case 70:
--YY_RULE_SETUP
--#line 729 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--        return isc::dhcp::Dhcp6Parser::make_ENCAPSULATE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("encapsulate", driver.loc_);
--    }
--}
--      YY_BREAK
--case 71:
--YY_RULE_SETUP
--#line 738 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::OPTION_DEF:
--        return isc::dhcp::Dhcp6Parser::make_ARRAY(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("array", driver.loc_);
--    }
--}
--      YY_BREAK
--case 72:
--YY_RULE_SETUP
--#line 747 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SUBNET6:
--        return isc::dhcp::Dhcp6Parser::make_RELAY(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("relay", driver.loc_);
--    }
--}
--      YY_BREAK
--case 73:
--YY_RULE_SETUP
--#line 756 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::RELAY:
--    return isc::dhcp::Dhcp6Parser::make_IP_ADDRESS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("ip-address", driver.loc_);
--    }
--}
--      YY_BREAK
--case 74:
--YY_RULE_SETUP
--#line 765 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_HOOKS_LIBRARIES(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("hooks-libraries", driver.loc_);
--    }
--}
--      YY_BREAK
--case 75:
--YY_RULE_SETUP
--#line 775 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::HOOKS_LIBRARIES:
--        return isc::dhcp::Dhcp6Parser::make_PARAMETERS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("parameters", driver.loc_);
--    }
--}
--      YY_BREAK
--case 76:
--YY_RULE_SETUP
--#line 784 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::HOOKS_LIBRARIES:
--        return isc::dhcp::Dhcp6Parser::make_LIBRARY(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("library", driver.loc_);
--    }
--}
--      YY_BREAK
--case 77:
--YY_RULE_SETUP
--#line 793 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_SERVER_ID(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("server-id", driver.loc_);
--    }
--}
--      YY_BREAK
--case 78:
--YY_RULE_SETUP
--#line 802 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SERVER_ID:
--        return isc::dhcp::Dhcp6Parser::make_IDENTIFIER(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("identifier", driver.loc_);
--    }
--}
--      YY_BREAK
--case 79:
--YY_RULE_SETUP
--#line 811 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SERVER_ID:
--        return isc::dhcp::Dhcp6Parser::make_HTYPE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("htype", driver.loc_);
--    }
--}
--      YY_BREAK
--case 80:
--YY_RULE_SETUP
--#line 820 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SERVER_ID:
--        return isc::dhcp::Dhcp6Parser::make_TIME(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("time", driver.loc_);
--    }
--}
--      YY_BREAK
--case 81:
--YY_RULE_SETUP
--#line 829 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::SERVER_ID:
--        return isc::dhcp::Dhcp6Parser::make_ENTERPRISE_ID(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("enterprise-id", driver.loc_);
--    }
--}
--      YY_BREAK
--case 82:
--YY_RULE_SETUP
--#line 838 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_EXPIRED_LEASES_PROCESSING(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("expired-leases-processing", driver.loc_);
--    }
--}
--      YY_BREAK
--case 83:
--YY_RULE_SETUP
--#line 847 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_DHCP4O6_PORT(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("dhcp4o6-port", driver.loc_);
--    }
--}
--      YY_BREAK
--case 84:
--YY_RULE_SETUP
--#line 856 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_VERSION(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("version", driver.loc_);
--    }
--}
--      YY_BREAK
--case 85:
--YY_RULE_SETUP
--#line 865 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_CONTROL_SOCKET(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("control-socket", driver.loc_);
--    }
--}
--      YY_BREAK
--case 86:
--YY_RULE_SETUP
--#line 874 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CONTROL_SOCKET:
--        return isc::dhcp::Dhcp6Parser::make_SOCKET_TYPE(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("socket-type", driver.loc_);
--    }
--}
--      YY_BREAK
--case 87:
--YY_RULE_SETUP
--#line 883 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CONTROL_SOCKET:
--        return isc::dhcp::Dhcp6Parser::make_SOCKET_NAME(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("socket-name", driver.loc_);
--    }
--}
--      YY_BREAK
--case 88:
--YY_RULE_SETUP
--#line 892 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::DHCP6:
--        return isc::dhcp::Dhcp6Parser::make_DHCP_DDNS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("dhcp-ddns", driver.loc_);
--    }
--}
--      YY_BREAK
--case 89:
--YY_RULE_SETUP
--#line 901 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CONFIG:
--        return isc::dhcp::Dhcp6Parser::make_DHCP4(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("Dhcp4", driver.loc_);
--    }
--}
--      YY_BREAK
--case 90:
--YY_RULE_SETUP
--#line 910 "dhcp6_lexer.ll"
--{
--    switch(driver.ctx_) {
--    case isc::dhcp::Parser6Context::CONFIG:
--        return isc::dhcp::Dhcp6Parser::make_DHCPDDNS(driver.loc_);
--    default:
--        return isc::dhcp::Dhcp6Parser::make_STRING("DhcpDdns", driver.loc_);
--    }
--}
--      YY_BREAK
--case 91:
--YY_RULE_SETUP
--#line 919 "dhcp6_lexer.ll"
--{
--    // A string has been matched. It contains the actual string and single quotes.
--    // We need to get those quotes out of the way and just use its content, e.g.
--    // for 'foo' we should get foo
--    std::string raw(parser6_text+1);
--    size_t len = raw.size() - 1;
--    raw.resize(len);
--    std::string decoded;
--    decoded.reserve(len);
--    for (size_t pos = 0; pos < len; ++pos) {
 -        int b = 0;
--        char c = raw[pos];
--        switch (c) {
--        case '"':
--            // impossible condition
--            driver.error(driver.loc_, "Bad quote in \"" + raw + "\"");
--        case '\\':
--            ++pos;
--            if (pos >= len) {
--                // impossible condition
--                driver.error(driver.loc_, "Overflow escape in \"" + raw + "\"");
--            }
--            c = raw[pos];
--            switch (c) {
--            case '"':
--            case '\\':
--            case '/':
--                decoded.push_back(c);
--                break;
--            case 'b':
--                decoded.push_back('\b');
--                break;
--            case 'f':
--                decoded.push_back('\f');
--                break;
--            case 'n':
--                decoded.push_back('\n');
--                break;
--            case 'r':
--                decoded.push_back('\r');
--                break;
--            case 't':
--                decoded.push_back('\t');
--                break;
--            case 'u':
-                 // not yet implemented
-                 driver.error(driver.loc_, "Unsupported unicode escape in \"" + raw + "\"");
 -                // support only \u0000 to \u00ff
 -                ++pos;
 -                if (pos + 4 > len) {
 -                    // impossible condition
 -                    driver.error(driver.loc_,
 -                                 "Overflow unicode escape in \"" + raw + "\"");
 -                }
 -                if ((raw[pos] != '0') || (raw[pos + 1] != '0')) {
 -                    driver.error(driver.loc_, "Unsupported unicode escape in \"" + raw + "\"");
 -                }
 -                pos += 2;
 -                c = raw[pos];
 -                if ((c >= '0') && (c <= '9')) {
 -                    b = (c - '0') << 4;
 -                } else if ((c >= 'A') && (c <= 'F')) {
 -                    b = (c - 'A' + 10) << 4;
 -                } else if ((c >= 'a') && (c <= 'f')) {
 -                    b = (c - 'a' + 10) << 4;
 -                } else {
 -                    // impossible condition
 -                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
 -                }
 -                pos++;
 -                c = raw[pos];
 -                if ((c >= '0') && (c <= '9')) {
 -                    b |= c - '0';
 -                } else if ((c >= 'A') && (c <= 'F')) {
 -                    b |= c - 'A' + 10;
 -                } else if ((c >= 'a') && (c <= 'f')) {
 -                    b |= c - 'a' + 10;
 -                } else {
 -                    // impossible condition
 -                    driver.error(driver.loc_, "Not hexadecimal in unicode escape in \"" + raw + "\"");
 -                }
 -                decoded.push_back(static_cast<char>(b & 0xff));
 -                break;
--            default:
--                // impossible condition
--                driver.error(driver.loc_, "Bad escape in \"" + raw + "\"");
--            }
--            break;
--        default:
--            if ((c >= 0) && (c < 0x20)) {
--                // impossible condition
--                driver.error(driver.loc_, "Invalid control in \"" + raw + "\"");
--            }
--            decoded.push_back(c);
--        }
--    }
--
--    return isc::dhcp::Dhcp6Parser::make_STRING(decoded, driver.loc_);
--}
--      YY_BREAK
--case 92:
--/* rule 92 can match eol */
--YY_RULE_SETUP
- #line 982 "dhcp6_lexer.ll"
 -#line 1017 "dhcp6_lexer.ll"
--{
--    // Bad string with a forbidden control character inside
--    driver.error(driver.loc_, "Invalid control in " + std::string(parser6_text));
--}
--      YY_BREAK
--case 93:
--/* rule 93 can match eol */
--YY_RULE_SETUP
- #line 987 "dhcp6_lexer.ll"
 -#line 1022 "dhcp6_lexer.ll"
--{
--    // Bad string with a bad escape inside
--    driver.error(driver.loc_, "Bad escape in " + std::string(parser6_text));
--}
--      YY_BREAK
--case 94:
--YY_RULE_SETUP
- #line 992 "dhcp6_lexer.ll"
 -#line 1027 "dhcp6_lexer.ll"
--{
--    // Bad string with an open escape at the end
--    driver.error(driver.loc_, "Overflow escape in " + std::string(parser6_text));
--}
--      YY_BREAK
--case 95:
--YY_RULE_SETUP
- #line 997 "dhcp6_lexer.ll"
 -#line 1032 "dhcp6_lexer.ll"
--{ return isc::dhcp::Dhcp6Parser::make_LSQUARE_BRACKET(driver.loc_); }
--      YY_BREAK
--case 96:
--YY_RULE_SETUP
- #line 998 "dhcp6_lexer.ll"
 -#line 1033 "dhcp6_lexer.ll"
--{ return isc::dhcp::Dhcp6Parser::make_RSQUARE_BRACKET(driver.loc_); }
--      YY_BREAK
--case 97:
--YY_RULE_SETUP
- #line 999 "dhcp6_lexer.ll"
 -#line 1034 "dhcp6_lexer.ll"
--{ return isc::dhcp::Dhcp6Parser::make_LCURLY_BRACKET(driver.loc_); }
--      YY_BREAK
--case 98:
--YY_RULE_SETUP
- #line 1000 "dhcp6_lexer.ll"
 -#line 1035 "dhcp6_lexer.ll"
--{ return isc::dhcp::Dhcp6Parser::make_RCURLY_BRACKET(driver.loc_); }
--      YY_BREAK
--case 99:
--YY_RULE_SETUP
- #line 1001 "dhcp6_lexer.ll"
 -#line 1036 "dhcp6_lexer.ll"
--{ return isc::dhcp::Dhcp6Parser::make_COMMA(driver.loc_); }
--      YY_BREAK
--case 100:
--YY_RULE_SETUP
- #line 1002 "dhcp6_lexer.ll"
 -#line 1037 "dhcp6_lexer.ll"
--{ return isc::dhcp::Dhcp6Parser::make_COLON(driver.loc_); }
--      YY_BREAK
--case 101:
--YY_RULE_SETUP
- #line 1004 "dhcp6_lexer.ll"
 -#line 1039 "dhcp6_lexer.ll"
--{
--    // An integer was found.
--    std::string tmp(parser6_text);
--    int64_t integer = 0;
--    try {
--        // In substring we want to use negative values (e.g. -1).
--        // In enterprise-id we need to use values up to 0xffffffff.
--        // To cover both of those use cases, we need at least
--        // int64_t.
--        integer = boost::lexical_cast<int64_t>(tmp);
--    } catch (const boost::bad_lexical_cast &) {
--        driver.error(driver.loc_, "Failed to convert " + tmp + " to an integer.");
--    }
--
--    // The parser needs the string form as double conversion is no lossless
--    return isc::dhcp::Dhcp6Parser::make_INTEGER(integer, driver.loc_);
--}
--      YY_BREAK
--case 102:
--YY_RULE_SETUP
- #line 1022 "dhcp6_lexer.ll"
 -#line 1057 "dhcp6_lexer.ll"
--{
--    // A floating point was found.
--    std::string tmp(parser6_text);
--    double fp = 0.0;
--    try {
--        fp = boost::lexical_cast<double>(tmp);
--    } catch (const boost::bad_lexical_cast &) {
--        driver.error(driver.loc_, "Failed to convert " + tmp + " to a floating point.");
--    }
--
--    return isc::dhcp::Dhcp6Parser::make_FLOAT(fp, driver.loc_);
--}
--      YY_BREAK
--case 103:
--YY_RULE_SETUP
- #line 1035 "dhcp6_lexer.ll"
 -#line 1070 "dhcp6_lexer.ll"
--{
--    string tmp(parser6_text);
--    return isc::dhcp::Dhcp6Parser::make_BOOLEAN(tmp == "true", driver.loc_);
--}
--      YY_BREAK
--case 104:
--YY_RULE_SETUP
- #line 1040 "dhcp6_lexer.ll"
 -#line 1075 "dhcp6_lexer.ll"
--{
--   return isc::dhcp::Dhcp6Parser::make_NULL_TYPE(driver.loc_);
--}
--      YY_BREAK
--case 105:
--YY_RULE_SETUP
- #line 1044 "dhcp6_lexer.ll"
 -#line 1079 "dhcp6_lexer.ll"
 -driver.error (driver.loc_, "JSON true reserved keyword is lower case only");
 -      YY_BREAK
 -case 106:
 -YY_RULE_SETUP
 -#line 1081 "dhcp6_lexer.ll"
 -driver.error (driver.loc_, "JSON false reserved keyword is lower case only");
 -      YY_BREAK
 -case 107:
 -YY_RULE_SETUP
 -#line 1083 "dhcp6_lexer.ll"
 -driver.error (driver.loc_, "JSON null reserved keyword is lower case only");
 -      YY_BREAK
 -case 108:
 -YY_RULE_SETUP
 -#line 1085 "dhcp6_lexer.ll"
--driver.error (driver.loc_, "Invalid character: " + std::string(parser6_text));
--      YY_BREAK
--case YY_STATE_EOF(INITIAL):
- #line 1046 "dhcp6_lexer.ll"
 -#line 1087 "dhcp6_lexer.ll"
--{
--    if (driver.states_.empty()) {
--        return isc::dhcp::Dhcp6Parser::make_END(driver.loc_);
--    }
--    driver.loc_ = driver.locs_.back();
--    driver.locs_.pop_back();
--    driver.file_ = driver.files_.back();
--    driver.files_.pop_back();
--    if (driver.sfile_) {
--        fclose(driver.sfile_);
--        driver.sfile_ = 0;
--    }
--    if (!driver.sfiles_.empty()) {
--        driver.sfile_ = driver.sfiles_.back();
--        driver.sfiles_.pop_back();
--    }
--    parser6__delete_buffer(YY_CURRENT_BUFFER);
--    parser6__switch_to_buffer(driver.states_.back());
--    driver.states_.pop_back();
--
--    BEGIN(DIR_EXIT);
--}
--      YY_BREAK
- case 106:
 -case 109:
--YY_RULE_SETUP
- #line 1069 "dhcp6_lexer.ll"
 -#line 1110 "dhcp6_lexer.ll"
--ECHO;
--      YY_BREAK
- #line 2814 "dhcp6_lexer.cc"
 -#line 3869 "dhcp6_lexer.cc"
--
--      case YY_END_OF_BUFFER:
--              {
--              /* Amount of text matched not including the EOB char. */
--              int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
--
--              /* Undo the effects of YY_DO_BEFORE_ACTION. */
--              *yy_cp = (yy_hold_char);
--              YY_RESTORE_YY_MORE_OFFSET
--
--              if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
--                      {
--                      /* We're scanning a new file or input source.  It's
--                       * possible that this happened because the user
--                       * just pointed parser6_in at a new source and called
--                       * parser6_lex().  If so, then we have to assure
--                       * consistency between YY_CURRENT_BUFFER and our
--                       * globals.  Here is the right place to do so, because
--                       * this is the first action (other than possibly a
--                       * back-up) that will match for the new input source.
--                       */
--                      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
--/* %if-c-only */
--                      YY_CURRENT_BUFFER_LVALUE->yy_input_file = parser6_in;
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--                      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
--                      }
--
--              /* Note that here we test for yy_c_buf_p "<=" to the position
--               * of the first EOB in the buffer, since yy_c_buf_p will
--               * already have been incremented past the NUL character
--               * (since all states make transitions on EOB to the
--               * end-of-buffer state).  Contrast this with the test
--               * in input().
--               */
--              if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
--                      { /* This was really a NUL. */
--                      yy_state_type yy_next_state;
--
--                      (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
--
--                      yy_current_state = yy_get_previous_state(  );
--
--                      /* Okay, we're now positioned to make the NUL
--                       * transition.  We couldn't have
--                       * yy_get_previous_state() go ahead and do it
--                       * for us because it doesn't know how to deal
--                       * with the possibility of jamming (and we don't
--                       * want to build jamming into it because then it
--                       * will run more slowly).
--                       */
--
--                      yy_next_state = yy_try_NUL_trans( yy_current_state );
--
--                      yy_bp = (yytext_ptr) + YY_MORE_ADJ;
--
--                      if ( yy_next_state )
--                              {
--                              /* Consume the NUL. */
--                              yy_cp = ++(yy_c_buf_p);
--                              yy_current_state = yy_next_state;
--                              goto yy_match;
--                              }
--
--                      else
--                              {
--/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
--                              yy_cp = (yy_last_accepting_cpos);
--                              yy_current_state = (yy_last_accepting_state);
--                              goto yy_find_action;
--                              }
--                      }
--
--              else switch ( yy_get_next_buffer(  ) )
--                      {
--                      case EOB_ACT_END_OF_FILE:
--                              {
--                              (yy_did_buffer_switch_on_eof) = 0;
--
--                              if ( parser6_wrap( ) )
--                                      {
--                                      /* Note: because we've taken care in
--                                       * yy_get_next_buffer() to have set up
--                                       * parser6_text, we can now set up
--                                       * yy_c_buf_p so that if some total
--                                       * hoser (like flex itself) wants to
--                                       * call the scanner after we return the
--                                       * YY_NULL, it'll still work - another
--                                       * YY_NULL will get returned.
--                                       */
--                                      (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
--
--                                      yy_act = YY_STATE_EOF(YY_START);
--                                      goto do_action;
--                                      }
--
--                              else
--                                      {
--                                      if ( ! (yy_did_buffer_switch_on_eof) )
--                                              YY_NEW_FILE;
--                                      }
--                              break;
--                              }
--
--                      case EOB_ACT_CONTINUE_SCAN:
--                              (yy_c_buf_p) =
--                                      (yytext_ptr) + yy_amount_of_matched_text;
--
--                              yy_current_state = yy_get_previous_state(  );
--
--                              yy_cp = (yy_c_buf_p);
--                              yy_bp = (yytext_ptr) + YY_MORE_ADJ;
--                              goto yy_match;
--
--                      case EOB_ACT_LAST_MATCH:
--                              (yy_c_buf_p) =
--                              &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
--
--                              yy_current_state = yy_get_previous_state(  );
--
--                              yy_cp = (yy_c_buf_p);
--                              yy_bp = (yytext_ptr) + YY_MORE_ADJ;
--                              goto yy_find_action;
--                      }
--              break;
--              }
--
--      default:
--              YY_FATAL_ERROR(
--                      "fatal flex scanner internal error--no action found" );
--      } /* end of action switch */
--              } /* end of scanning one token */
--      } /* end of user's declarations */
--} /* end of parser6_lex */
--/* %ok-for-header */
--
--/* %if-c++-only */
--/* %not-for-header */
--
--/* %ok-for-header */
--
--/* %endif */
--
--/* yy_get_next_buffer - try to read in a new buffer
-- *
-- * Returns a code representing an action:
-- *    EOB_ACT_LAST_MATCH -
-- *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
-- *    EOB_ACT_END_OF_FILE - end of file
-- */
--/* %if-c-only */
--static int yy_get_next_buffer (void)
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
--      char *source = (yytext_ptr);
--      yy_size_t number_to_move, i;
--      int ret_val;
--
--      if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
--              YY_FATAL_ERROR(
--              "fatal flex scanner internal error--end of buffer missed" );
--
--      if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
--              { /* Don't try to fill the buffer, so this is an EOF. */
--              if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
--                      {
--                      /* We matched a single character, the EOB, so
--                       * treat this as a final EOF.
--                       */
--                      return EOB_ACT_END_OF_FILE;
--                      }
--
--              else
--                      {
--                      /* We matched some text prior to the EOB, first
--                       * process it.
--                       */
--                      return EOB_ACT_LAST_MATCH;
--                      }
--              }
--
--      /* Try to read more data. */
--
--      /* First move last chars to start of buffer. */
--      number_to_move = (yy_size_t) ((yy_c_buf_p) - (yytext_ptr)) - 1;
--
--      for ( i = 0; i < number_to_move; ++i )
--              *(dest++) = *(source++);
--
--      if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
--              /* don't do the read, it's not guaranteed to return an EOF,
--               * just force an EOF
--               */
--              YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
--
--      else
--              {
-                       yy_size_t num_to_read =
 -                      int num_to_read =
--                      YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
--
--              while ( num_to_read <= 0 )
--                      { /* Not enough room in the buffer - grow it. */
--
--                      /* just a shorter name for the current buffer */
--                      YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
--
--                      int yy_c_buf_p_offset =
--                              (int) ((yy_c_buf_p) - b->yy_ch_buf);
--
--                      if ( b->yy_is_our_buffer )
--                              {
-                               yy_size_t new_size = b->yy_buf_size * 2;
 -                              int new_size = b->yy_buf_size * 2;
--
--                              if ( new_size <= 0 )
--                                      b->yy_buf_size += b->yy_buf_size / 8;
--                              else
--                                      b->yy_buf_size *= 2;
--
--                              b->yy_ch_buf = (char *)
--                                      /* Include room in for 2 EOB chars. */
--                                      parser6_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
--                              }
--                      else
--                              /* Can't grow it, we don't own it. */
-                               b->yy_ch_buf = 0;
 -                              b->yy_ch_buf = NULL;
--
--                      if ( ! b->yy_ch_buf )
--                              YY_FATAL_ERROR(
--                              "fatal error - scanner input buffer overflow" );
--
--                      (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
--
--                      num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
--                                              number_to_move - 1;
--
--                      }
--
--              if ( num_to_read > YY_READ_BUF_SIZE )
--                      num_to_read = YY_READ_BUF_SIZE;
--
--              /* Read in more data. */
--              YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
--                      (yy_n_chars), num_to_read );
--
--              YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
--              }
--
--      if ( (yy_n_chars) == 0 )
--              {
--              if ( number_to_move == YY_MORE_ADJ )
--                      {
--                      ret_val = EOB_ACT_END_OF_FILE;
--                      parser6_restart(parser6_in  );
--                      }
--
--              else
--                      {
--                      ret_val = EOB_ACT_LAST_MATCH;
--                      YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
--                              YY_BUFFER_EOF_PENDING;
--                      }
--              }
--
--      else
--              ret_val = EOB_ACT_CONTINUE_SCAN;
--
--      if ((int) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
--              /* Extend the array by 50%, plus the number we really need. */
--              int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
--              YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) parser6_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
--              if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
--                      YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
--      }
--
--      (yy_n_chars) += number_to_move;
--      YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
--      YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
--
--      (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
--
--      return ret_val;
--}
--
--/* yy_get_previous_state - get the state just before the EOB char was reached */
--
--/* %if-c-only */
--/* %not-for-header */
--
--    static yy_state_type yy_get_previous_state (void)
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      yy_state_type yy_current_state;
--      char *yy_cp;
--    
--/* %% [15.0] code to get the start state into yy_current_state goes here */
--      yy_current_state = (yy_start);
--
--      for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
--              {
--/* %% [16.0] code to find the next state goes here */
--              YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
--              if ( yy_accept[yy_current_state] )
--                      {
--                      (yy_last_accepting_state) = yy_current_state;
--                      (yy_last_accepting_cpos) = yy_cp;
--                      }
--              while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
--                      {
--                      yy_current_state = (int) yy_def[yy_current_state];
-                       if ( yy_current_state >= 759 )
 -                      if ( yy_current_state >= 773 )
--                              yy_c = yy_meta[(unsigned int) yy_c];
--                      }
-               yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 -              yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
--              }
--
--      return yy_current_state;
--}
--
--/* yy_try_NUL_trans - try to make a transition on the NUL character
-- *
-- * synopsis
-- *    next_state = yy_try_NUL_trans( current_state );
-- */
--/* %if-c-only */
--    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      int yy_is_jam;
--    /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */
--      char *yy_cp = (yy_c_buf_p);
--
--      YY_CHAR yy_c = 1;
--      if ( yy_accept[yy_current_state] )
--              {
--              (yy_last_accepting_state) = yy_current_state;
--              (yy_last_accepting_cpos) = yy_cp;
--              }
--      while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
--              {
--              yy_current_state = (int) yy_def[yy_current_state];
-               if ( yy_current_state >= 759 )
 -              if ( yy_current_state >= 773 )
--                      yy_c = yy_meta[(unsigned int) yy_c];
--              }
-       yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-       yy_is_jam = (yy_current_state == 758);
 -      yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
 -      yy_is_jam = (yy_current_state == 772);
--
--              return yy_is_jam ? 0 : yy_current_state;
--}
--
--#ifndef YY_NO_UNPUT
--/* %if-c-only */
--
--/* %endif */
--#endif
--
--/* %if-c-only */
--#ifndef YY_NO_INPUT
--#ifdef __cplusplus
--    static int yyinput (void)
--#else
--    static int input  (void)
--#endif
--
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      int c;
--    
--      *(yy_c_buf_p) = (yy_hold_char);
--
--      if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
--              {
--              /* yy_c_buf_p now points to the character we want to return.
--               * If this occurs *before* the EOB characters, then it's a
--               * valid NUL; if not, then we've hit the end of the buffer.
--               */
--              if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
--                      /* This was really a NUL. */
--                      *(yy_c_buf_p) = '\0';
--
--              else
--                      { /* need more input */
-                       yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
 -                      int offset = (yy_c_buf_p) - (yytext_ptr);
--                      ++(yy_c_buf_p);
--
--                      switch ( yy_get_next_buffer(  ) )
--                              {
--                              case EOB_ACT_LAST_MATCH:
--                                      /* This happens because yy_g_n_b()
--                                       * sees that we've accumulated a
--                                       * token and flags that we need to
--                                       * try matching the token before
--                                       * proceeding.  But for input(),
--                                       * there's no matching to consider.
--                                       * So convert the EOB_ACT_LAST_MATCH
--                                       * to EOB_ACT_END_OF_FILE.
--                                       */
--
--                                      /* Reset buffer status. */
--                                      parser6_restart(parser6_in );
--
--                                      /*FALLTHROUGH*/
--
--                              case EOB_ACT_END_OF_FILE:
--                                      {
--                                      if ( parser6_wrap( ) )
-                                               return EOF;
 -                                              return 0;
--
--                                      if ( ! (yy_did_buffer_switch_on_eof) )
--                                              YY_NEW_FILE;
--#ifdef __cplusplus
--                                      return yyinput();
--#else
--                                      return input();
--#endif
--                                      }
--
--                              case EOB_ACT_CONTINUE_SCAN:
--                                      (yy_c_buf_p) = (yytext_ptr) + offset;
--                                      break;
--                              }
--                      }
--              }
--
--      c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
--      *(yy_c_buf_p) = '\0';   /* preserve parser6_text */
--      (yy_hold_char) = *++(yy_c_buf_p);
--
--/* %% [19.0] update BOL and parser6_lineno */
--
--      return c;
--}
--/* %if-c-only */
--#endif        /* ifndef YY_NO_INPUT */
--/* %endif */
--
--/** Immediately switch to a different input stream.
-- * @param input_file A readable stream.
-- * 
-- * @note This function does not reset the start condition to @c INITIAL .
-- */
--/* %if-c-only */
--    void parser6_restart  (FILE * input_file )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--    
--      if ( ! YY_CURRENT_BUFFER ){
--        parser6_ensure_buffer_stack ();
--              YY_CURRENT_BUFFER_LVALUE =
--            parser6__create_buffer(parser6_in,YY_BUF_SIZE );
--      }
--
--      parser6__init_buffer(YY_CURRENT_BUFFER,input_file );
--      parser6__load_buffer_state( );
--}
--
--/* %if-c++-only */
--/* %endif */
--
--/** Switch to a different input buffer.
-- * @param new_buffer The new input buffer.
-- * 
-- */
--/* %if-c-only */
--    void parser6__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--    
--      /* TODO. We should be able to replace this entire function body
--       * with
--       *              parser6_pop_buffer_state();
--       *              parser6_push_buffer_state(new_buffer);
--     */
--      parser6_ensure_buffer_stack ();
--      if ( YY_CURRENT_BUFFER == new_buffer )
--              return;
--
--      if ( YY_CURRENT_BUFFER )
--              {
--              /* Flush out information for old buffer. */
--              *(yy_c_buf_p) = (yy_hold_char);
--              YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
--              YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
--              }
--
--      YY_CURRENT_BUFFER_LVALUE = new_buffer;
--      parser6__load_buffer_state( );
--
--      /* We don't actually know whether we did this switch during
--       * EOF (parser6_wrap()) processing, but the only time this flag
--       * is looked at is after parser6_wrap() is called, so it's safe
--       * to go ahead and always set it.
--       */
--      (yy_did_buffer_switch_on_eof) = 1;
--}
--
--/* %if-c-only */
--static void parser6__load_buffer_state  (void)
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
--      (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
--/* %if-c-only */
--      parser6_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--      (yy_hold_char) = *(yy_c_buf_p);
--}
--
--/** Allocate and initialize an input buffer state.
-- * @param file A readable stream.
-- * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
-- * 
-- * @return the allocated buffer state.
-- */
--/* %if-c-only */
--    YY_BUFFER_STATE parser6__create_buffer  (FILE * file, int  size )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      YY_BUFFER_STATE b;
--    
--      b = (YY_BUFFER_STATE) parser6_alloc(sizeof( struct yy_buffer_state )  );
--      if ( ! b )
--              YY_FATAL_ERROR( "out of dynamic memory in parser6__create_buffer()" );
--
--      b->yy_buf_size = (yy_size_t)size;
--
--      /* yy_ch_buf has to be 2 characters longer than the size given because
--       * we need to put in 2 end-of-buffer characters.
--       */
--      b->yy_ch_buf = (char *) parser6_alloc(b->yy_buf_size + 2  );
--      if ( ! b->yy_ch_buf )
--              YY_FATAL_ERROR( "out of dynamic memory in parser6__create_buffer()" );
--
--      b->yy_is_our_buffer = 1;
--
--      parser6__init_buffer(b,file );
--
--      return b;
--}
--
--/* %if-c++-only */
--/* %endif */
--
--/** Destroy the buffer.
-- * @param b a buffer created with parser6__create_buffer()
-- * 
-- */
--/* %if-c-only */
--    void parser6__delete_buffer (YY_BUFFER_STATE  b )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--    
--      if ( ! b )
--              return;
--
--      if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
--              YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
--
--      if ( b->yy_is_our_buffer )
--              parser6_free((void *) b->yy_ch_buf  );
--
--      parser6_free((void *) b  );
--}
--
--/* Initializes or reinitializes a buffer.
-- * This function is sometimes called more than once on the same buffer,
-- * such as during a parser6_restart() or at EOF.
-- */
--/* %if-c-only */
--    static void parser6__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--
--{
--      int oerrno = errno;
--    
--      parser6__flush_buffer(b );
--
--/* %if-c-only */
--      b->yy_input_file = file;
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--      b->yy_fill_buffer = 1;
--
--    /* If b is the current buffer, then parser6__init_buffer was _probably_
--     * called from parser6_restart() or through yy_get_next_buffer.
--     * In that case, we don't want to reset the lineno or column.
--     */
--    if (b != YY_CURRENT_BUFFER){
--        b->yy_bs_lineno = 1;
--        b->yy_bs_column = 0;
--    }
--
--/* %if-c-only */
--
--        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
--    
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--      errno = oerrno;
--}
--
--/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
-- * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
-- * 
-- */
--/* %if-c-only */
--    void parser6__flush_buffer (YY_BUFFER_STATE  b )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      if ( ! b )
--              return;
--
--      b->yy_n_chars = 0;
--
--      /* We always need two end-of-buffer characters.  The first causes
--       * a transition to the end-of-buffer state.  The second causes
--       * a jam in that state.
--       */
--      b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
--      b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
--
--      b->yy_buf_pos = &b->yy_ch_buf[0];
--
--      b->yy_at_bol = 1;
--      b->yy_buffer_status = YY_BUFFER_NEW;
--
--      if ( b == YY_CURRENT_BUFFER )
--              parser6__load_buffer_state( );
--}
--
--/* %if-c-or-c++ */
--/** Pushes the new state onto the stack. The new state becomes
-- *  the current state. This function will allocate the stack
-- *  if necessary.
-- *  @param new_buffer The new state.
-- *  
-- */
--/* %if-c-only */
--void parser6_push_buffer_state (YY_BUFFER_STATE new_buffer )
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      if (new_buffer == NULL)
--              return;
--
--      parser6_ensure_buffer_stack();
--
--      /* This block is copied from parser6__switch_to_buffer. */
--      if ( YY_CURRENT_BUFFER )
--              {
--              /* Flush out information for old buffer. */
--              *(yy_c_buf_p) = (yy_hold_char);
--              YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
--              YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
--              }
--
--      /* Only push if top exists. Otherwise, replace top. */
--      if (YY_CURRENT_BUFFER)
--              (yy_buffer_stack_top)++;
--      YY_CURRENT_BUFFER_LVALUE = new_buffer;
--
--      /* copied from parser6__switch_to_buffer. */
--      parser6__load_buffer_state( );
--      (yy_did_buffer_switch_on_eof) = 1;
--}
--/* %endif */
--
--/* %if-c-or-c++ */
--/** Removes and deletes the top of the stack, if present.
-- *  The next element becomes the new top.
-- *  
-- */
--/* %if-c-only */
--void parser6_pop_buffer_state (void)
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
--      if (!YY_CURRENT_BUFFER)
--              return;
--
--      parser6__delete_buffer(YY_CURRENT_BUFFER );
--      YY_CURRENT_BUFFER_LVALUE = NULL;
--      if ((yy_buffer_stack_top) > 0)
--              --(yy_buffer_stack_top);
--
--      if (YY_CURRENT_BUFFER) {
--              parser6__load_buffer_state( );
--              (yy_did_buffer_switch_on_eof) = 1;
--      }
--}
--/* %endif */
--
--/* %if-c-or-c++ */
--/* Allocates the stack if it does not exist.
-- *  Guarantees space for at least one push.
-- */
--/* %if-c-only */
--static void parser6_ensure_buffer_stack (void)
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--{
-       yy_size_t num_to_alloc;
 -      int num_to_alloc;
--    
--      if (!(yy_buffer_stack)) {
--
--              /* First allocation is just for 2 elements, since we don't know if this
--               * scanner will even need a stack. We use 2 instead of 1 to avoid an
--               * immediate realloc on the next call.
--         */
-               num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
 -      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
--              (yy_buffer_stack) = (struct yy_buffer_state**)parser6_alloc
--                                                              (num_to_alloc * sizeof(struct yy_buffer_state*)
--                                                              );
--              if ( ! (yy_buffer_stack) )
--                      YY_FATAL_ERROR( "out of dynamic memory in parser6_ensure_buffer_stack()" );
--                                                                
--              memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
--                              
--              (yy_buffer_stack_max) = num_to_alloc;
--              (yy_buffer_stack_top) = 0;
--              return;
--      }
--
--      if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
--
--              /* Increase the buffer to prepare for a possible push. */
--              yy_size_t grow_size = 8 /* arbitrary grow size */;
--
--              num_to_alloc = (yy_buffer_stack_max) + grow_size;
--              (yy_buffer_stack) = (struct yy_buffer_state**)parser6_realloc
--                                                              ((yy_buffer_stack),
--                                                              num_to_alloc * sizeof(struct yy_buffer_state*)
--                                                              );
--              if ( ! (yy_buffer_stack) )
--                      YY_FATAL_ERROR( "out of dynamic memory in parser6_ensure_buffer_stack()" );
--
--              /* zero only the new slots.*/
--              memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
--              (yy_buffer_stack_max) = num_to_alloc;
--      }
--}
--/* %endif */
--
--/* %if-c-only */
--/** Setup the input buffer state to scan directly from a user-specified character buffer.
-- * @param base the character buffer
-- * @param size the size in bytes of the character buffer
-- * 
-- * @return the newly allocated buffer state object. 
-- */
--YY_BUFFER_STATE parser6__scan_buffer  (char * base, yy_size_t  size )
--{
--      YY_BUFFER_STATE b;
--    
--      if ( size < 2 ||
--           base[size-2] != YY_END_OF_BUFFER_CHAR ||
--           base[size-1] != YY_END_OF_BUFFER_CHAR )
--              /* They forgot to leave room for the EOB's. */
-               return 0;
 -              return NULL;
--
--      b = (YY_BUFFER_STATE) parser6_alloc(sizeof( struct yy_buffer_state )  );
--      if ( ! b )
--              YY_FATAL_ERROR( "out of dynamic memory in parser6__scan_buffer()" );
--
--      b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
--      b->yy_buf_pos = b->yy_ch_buf = base;
--      b->yy_is_our_buffer = 0;
-       b->yy_input_file = 0;
 -      b->yy_input_file = NULL;
--      b->yy_n_chars = b->yy_buf_size;
--      b->yy_is_interactive = 0;
--      b->yy_at_bol = 1;
--      b->yy_fill_buffer = 0;
--      b->yy_buffer_status = YY_BUFFER_NEW;
--
--      parser6__switch_to_buffer(b  );
--
--      return b;
--}
--/* %endif */
--
--/* %if-c-only */
--/** Setup the input buffer state to scan a string. The next call to parser6_lex() will
-- * scan from a @e copy of @a str.
-- * @param yystr a NUL-terminated string to scan
-- * 
-- * @return the newly allocated buffer state object.
-- * @note If you want to scan bytes that may contain NUL values, then use
-- *       parser6__scan_bytes() instead.
-- */
--YY_BUFFER_STATE parser6__scan_string (yyconst char * yystr )
--{
--    
-       return parser6__scan_bytes(yystr,strlen(yystr) );
 -      return parser6__scan_bytes(yystr,(int) strlen(yystr) );
--}
--/* %endif */
--
--/* %if-c-only */
--/** Setup the input buffer state to scan the given bytes. The next call to parser6_lex() will
-- * scan from a @e copy of @a bytes.
-- * @param yybytes the byte buffer to scan
-- * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
-- * 
-- * @return the newly allocated buffer state object.
-- */
- YY_BUFFER_STATE parser6__scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
 -YY_BUFFER_STATE parser6__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
--{
--      YY_BUFFER_STATE b;
--      char *buf;
--      yy_size_t n;
--      yy_size_t i;
--    
--      /* Get memory for full buffer, including space for trailing EOB's. */
-       n = _yybytes_len + 2;
 -      n = (yy_size_t) _yybytes_len + 2;
--      buf = (char *) parser6_alloc(n  );
--      if ( ! buf )
--              YY_FATAL_ERROR( "out of dynamic memory in parser6__scan_bytes()" );
--
--      for ( i = 0; i < _yybytes_len; ++i )
--              buf[i] = yybytes[i];
--
--      buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
--
--      b = parser6__scan_buffer(buf,n );
--      if ( ! b )
--              YY_FATAL_ERROR( "bad buffer in parser6__scan_bytes()" );
--
--      /* It's okay to grow etc. this buffer, and we should throw it
--       * away when we're done.
--       */
--      b->yy_is_our_buffer = 1;
--
--      return b;
--}
--/* %endif */
--
--#ifndef YY_EXIT_FAILURE
--#define YY_EXIT_FAILURE 2
--#endif
--
--/* %if-c-only */
- static void yy_fatal_error (yyconst char* msg )
 -static void yynoreturn yy_fatal_error (yyconst char* msg )
--{
--                      (void) fprintf( stderr, "%s\n", msg );
--      exit( YY_EXIT_FAILURE );
--}
--/* %endif */
--/* %if-c++-only */
--/* %endif */
--
--/* Redefine yyless() so it works in section 3 code. */
--
--#undef yyless
--#define yyless(n) \
--      do \
--              { \
--              /* Undo effects of setting up parser6_text. */ \
--        int yyless_macro_arg = (n); \
--        YY_LESS_LINENO(yyless_macro_arg);\
--              parser6_text[parser6_leng] = (yy_hold_char); \
--              (yy_c_buf_p) = parser6_text + yyless_macro_arg; \
--              (yy_hold_char) = *(yy_c_buf_p); \
--              *(yy_c_buf_p) = '\0'; \
--              parser6_leng = yyless_macro_arg; \
--              } \
--      while ( 0 )
--
--/* Accessor  methods (get/set functions) to struct members. */
--
--/* %if-c-only */
--/* %if-reentrant */
--/* %endif */
--
--/** Get the current line number.
-- * 
-- */
--int parser6_get_lineno  (void)
--{
--        
--    return parser6_lineno;
--}
--
--/** Get the input stream.
-- * 
-- */
--FILE *parser6_get_in  (void)
--{
--        return parser6_in;
--}
--
--/** Get the output stream.
-- * 
-- */
--FILE *parser6_get_out  (void)
--{
--        return parser6_out;
--}
--
--/** Get the length of the current token.
-- * 
-- */
- yy_size_t parser6_get_leng  (void)
 -int parser6_get_leng  (void)
--{
--        return parser6_leng;
--}
--
--/** Get the current token.
-- * 
-- */
--
--char *parser6_get_text  (void)
--{
--        return parser6_text;
--}
--
--/* %if-reentrant */
--/* %endif */
--
--/** Set the current line number.
-- * @param _line_number line number
-- * 
-- */
--void parser6_set_lineno (int  _line_number )
--{
--    
--    parser6_lineno = _line_number;
--}
--
--/** Set the input stream. This does not discard the current
-- * input buffer.
-- * @param _in_str A readable stream.
-- * 
-- * @see parser6__switch_to_buffer
-- */
--void parser6_set_in (FILE *  _in_str )
--{
--        parser6_in = _in_str ;
--}
--
--void parser6_set_out (FILE *  _out_str )
--{
--        parser6_out = _out_str ;
--}
--
--int parser6_get_debug  (void)
--{
--        return parser6__flex_debug;
--}
--
--void parser6_set_debug (int  _bdebug )
--{
--        parser6__flex_debug = _bdebug ;
--}
--
--/* %endif */
--
--/* %if-reentrant */
--/* %if-bison-bridge */
--/* %endif */
--/* %endif if-c-only */
--
--/* %if-c-only */
--static int yy_init_globals (void)
--{
--        /* Initialization is the same as for the non-reentrant scanner.
--     * This function is called from parser6_lex_destroy(), so don't allocate here.
--     */
--
-     (yy_buffer_stack) = 0;
 -    (yy_buffer_stack) = NULL;
--    (yy_buffer_stack_top) = 0;
--    (yy_buffer_stack_max) = 0;
-     (yy_c_buf_p) = (char *) 0;
 -    (yy_c_buf_p) = NULL;
--    (yy_init) = 0;
--    (yy_start) = 0;
--
--/* Defined in main.c */
--#ifdef YY_STDINIT
--    parser6_in = stdin;
--    parser6_out = stdout;
--#else
-     parser6_in = (FILE *) 0;
-     parser6_out = (FILE *) 0;
 -    parser6_in = NULL;
 -    parser6_out = NULL;
--#endif
--
--    /* For future reference: Set errno on error, since we are called by
--     * parser6_lex_init()
--     */
--    return 0;
--}
--/* %endif */
--
--/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */
--/* parser6_lex_destroy is for both reentrant and non-reentrant scanners. */
--int parser6_lex_destroy  (void)
--{
--    
--    /* Pop the buffer stack, destroying each element. */
--      while(YY_CURRENT_BUFFER){
--              parser6__delete_buffer(YY_CURRENT_BUFFER  );
--              YY_CURRENT_BUFFER_LVALUE = NULL;
--              parser6_pop_buffer_state();
--      }
--
--      /* Destroy the stack itself. */
--      parser6_free((yy_buffer_stack) );
--      (yy_buffer_stack) = NULL;
--
--    /* Reset the globals. This is important in a non-reentrant scanner so the next time
--     * parser6_lex() is called, initialization will occur. */
--    yy_init_globals( );
--
--/* %if-reentrant */
--/* %endif */
--    return 0;
--}
--/* %endif */
--
--/*
-- * Internal utility routines.
-- */
--
--#ifndef yytext_ptr
--static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
--{
--              
--      int i;
--      for ( i = 0; i < n; ++i )
--              s1[i] = s2[i];
--}
--#endif
--
--#ifdef YY_NEED_STRLEN
--static int yy_flex_strlen (yyconst char * s )
--{
--      int n;
--      for ( n = 0; s[n]; ++n )
--              ;
--
--      return n;
--}
--#endif
--
--void *parser6_alloc (yy_size_t  size )
--{
-                       return (void *) malloc( size );
 -                      return malloc(size);
--}
--
--void *parser6_realloc  (void * ptr, yy_size_t  size )
--{
--              
--      /* The cast to (char *) in the following accommodates both
--       * implementations that use char* generic pointers, and those
--       * that use void* generic pointers.  It works with the latter
--       * because both ANSI C and C++ allow castless assignment from
--       * any pointer type to void*, and deal with argument conversions
--       * as though doing an assignment.
--       */
-       return (void *) realloc( (char *) ptr, size );
 -      return realloc(ptr, size);
--}
--
--void parser6_free (void * ptr )
--{
--                      free( (char *) ptr );   /* see parser6_realloc() for (char *) cast */
--}
--
--/* %if-tables-serialization definitions */
--/* %define-yytables   The name for this specific scanner's tables. */
--#define YYTABLES_NAME "yytables"
--/* %endif */
--
--/* %ok-for-header */
--
- #line 1069 "dhcp6_lexer.ll"
 -#line 1110 "dhcp6_lexer.ll"
--
--
--
--using namespace isc::dhcp;
--
--void
--Parser6Context::scanStringBegin(const std::string& str, ParserType parser_type)
--{
--    start_token_flag = true;
--    start_token_value = parser_type;
--
--    file_ = "<string>";
--    sfile_ = 0;
--    loc_.initialize(&file_);
--    parser6__flex_debug = trace_scanning_;
--    YY_BUFFER_STATE buffer;
--    buffer = parser6__scan_bytes(str.c_str(),str.size());
--    if (!buffer) {
--        fatal("cannot scan string");
--        // fatal() throws an exception so this can't be reached
--    }
--}
--
--void
--Parser6Context::scanFileBegin(FILE * f,
--                              const std::string& filename,
--                              ParserType parser_type)
--{
--    start_token_flag = true;
--    start_token_value = parser_type;
--
--    file_ = filename;
--    sfile_ = f;
--    loc_.initialize(&file_);
--    parser6__flex_debug = trace_scanning_;
--    YY_BUFFER_STATE buffer;
--
--    // See dhcp6_lexer.cc header for available definitions
--    buffer = parser6__create_buffer(f, 65536 /*buffer size*/);
--    if (!buffer) {
--        fatal("cannot scan file " + filename);
--    }
--    parser6__switch_to_buffer(buffer);
--}
--
--void
--Parser6Context::scanEnd() {
--    if (sfile_)
--        fclose(sfile_);
--    sfile_ = 0;
--    static_cast<void>(parser6_lex_destroy());
--    // Close files
--    while (!sfiles_.empty()) {
--        FILE* f = sfiles_.back();
--        if (f) {
--            fclose(f);
--        }
--        sfiles_.pop_back();
--    }
--    // Delete states
--    while (!states_.empty()) {
--        parser6__delete_buffer(states_.back());
--        states_.pop_back();
--    }
--}
--
--void
--Parser6Context::includeFile(const std::string& filename) {
--    if (states_.size() > 10) {
--        fatal("Too many nested include.");
--    }
--
--    FILE* f = fopen(filename.c_str(), "r");
--    if (!f) {
--        fatal("Can't open include file " + filename);
--    }
--    if (sfile_) {
--        sfiles_.push_back(sfile_);
--    }
--    sfile_ = f;
--    states_.push_back(YY_CURRENT_BUFFER);
--    YY_BUFFER_STATE buffer;
--    buffer = parser6__create_buffer(f, 65536 /*buffer size*/);
--    if (!buffer) {
--        fatal( "Can't scan include file " + filename);
--    }
--    parser6__switch_to_buffer(buffer);
--    files_.push_back(file_);
--    file_ = filename;
--    locs_.push_back(loc_);
--    loc_.initialize(&file_);
--
--    BEGIN(INITIAL);
--}
--
--namespace {
--/// To avoid unused function error
--class Dummy {
--    // cppcheck-suppress unusedPrivateFunction
--    void dummy() { yy_fatal_error("Fix me: how to disable its definition?"); }
--};
--}
--

diff --cc src/bin/dhcp6/dhcp6_lexer.ll
Simple merge