220#  pragma GCC message "bison: do not #define PARSER6_STYPE in C++, use %define api.value.type" 
  238      , yytypeid_ (YY_NULLPTR)
 
 
  242    template <
typename T>
 
  244      : yytypeid_ (&typeid (T))
 
  247      new (yyas_<T> ()) T (
YY_MOVE (t));
 
 
  250#if 201103L <= YY_CPLUSPLUS 
  263# if 201103L <= YY_CPLUSPLUS 
  265    template <
typename T, 
typename... U>
 
  271      yytypeid_ = & 
typeid (T);
 
  272      return *
new (yyas_<T> ()) T (std::forward <U>(u)...);
 
  276    template <
typename T>
 
  282      yytypeid_ = & 
typeid (T);
 
  283      return *
new (yyas_<T> ()) T ();
 
 
  287    template <
typename T>
 
  293      yytypeid_ = & 
typeid (T);
 
  294      return *
new (yyas_<T> ()) T (t);
 
 
  300    template <
typename T>
 
  309    template <
typename T>
 
  317    template <
typename T>
 
  328    template <
typename T>
 
  346    template <
typename T>
 
  352      std::swap (
as<T> (), that.as<T> ());
 
 
  358    template <
typename T>
 
  362# if 201103L <= YY_CPLUSPLUS 
 
  371# if 201103L <= YY_CPLUSPLUS 
  373    template <
typename T>
 
  383    template <
typename T>
 
  391    template <
typename T>
 
  396      yytypeid_ = YY_NULLPTR;
 
 
  400#if YY_CPLUSPLUS < 201103L 
  408    template <
typename T>
 
  413      return static_cast<T*
> (yyp);
 
  417    template <
typename T>
 
  422      return static_cast<const T*
> (yyp);
 
  441      char dummy2[
sizeof (bool)];
 
  444      char dummy3[
sizeof (double)];
 
  447      char dummy4[
sizeof (int64_t)];
 
  450      char dummy5[
sizeof (std::string)];
 
  454    enum { size = 
sizeof (union_type) };
 
  466    const std::type_info *yytypeid_;
 
 
  480        : std::runtime_error (m)
 
 
  485        : std::runtime_error (s.what ())
 
 
 
 1521    template <
typename Base>
 
 1533#if 201103L <= YY_CPLUSPLUS 
 1536        : Base (std::move (that))
 
 1538        , location (std::move (that.location))
 
 1540        switch (this->kind ())
 
 1552        value.move< 
ElementPtr > (std::move (that.value));
 
 1556        value.move< 
bool > (std::move (that.value));
 
 1560        value.move< 
double > (std::move (that.value));
 
 1564        value.move< int64_t > (std::move (that.value));
 
 1568        value.move< std::string > (std::move (that.value));
 
 1582#if 201103L <= YY_CPLUSPLUS 
 1594#if 201103L <= YY_CPLUSPLUS 
 1597        , value (std::move (v))
 
 1598        , location (std::move (l))
 
 1608#if 201103L <= YY_CPLUSPLUS 
 1611        , value (std::move (v))
 
 1612        , location (std::move (l))
 
 1622#if 201103L <= YY_CPLUSPLUS 
 1625        , value (std::move (v))
 
 1626        , location (std::move (l))
 
 1636#if 201103L <= YY_CPLUSPLUS 
 1639        , value (std::move (v))
 
 1640        , location (std::move (l))
 
 1650#if 201103L <= YY_CPLUSPLUS 
 1653        , value (std::move (v))
 
 1654        , location (std::move (l))
 
 1698        value.template destroy< ElementPtr > ();
 
 1702        value.template destroy< bool > ();
 
 1706        value.template destroy< double > ();
 
 1710        value.template destroy< int64_t > ();
 
 1714        value.template destroy< std::string > ();
 
 
 1746#if YY_CPLUSPLUS < 201103L 
 
 1761#if 201103L <= YY_CPLUSPLUS 
 
 1805#if 201103L <= YY_CPLUSPLUS 
 1813#if !defined _MSC_VER || defined __clang__ 
 
 1818#if 201103L <= YY_CPLUSPLUS 
 1826#if !defined _MSC_VER || defined __clang__ 
 
 1830#if 201103L <= YY_CPLUSPLUS 
 1838#if !defined _MSC_VER || defined __clang__ 
 
 1842#if 201103L <= YY_CPLUSPLUS 
 1850#if !defined _MSC_VER || defined __clang__ 
 
 1854#if 201103L <= YY_CPLUSPLUS 
 1862#if !defined _MSC_VER || defined __clang__ 
 
 
 1872#if 201103L <= YY_CPLUSPLUS 
 1885    virtual int parse ();
 
 1891    void set_debug_stream (std::ostream &);
 
 1894    typedef 
int debug_level_type;
 
 1898    void set_debug_level (debug_level_type l);
 
 1904    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1907    void error (
const syntax_error& err);
 
 1911    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1914#if 201103L <= YY_CPLUSPLUS 
 1917      make_END (location_type l)
 
 1919        return symbol_type (token::TOKEN_END, std::move (l));
 
 1929#if 201103L <= YY_CPLUSPLUS 
 1932      make_PARSER6_error (location_type l)
 
 1934        return symbol_type (token::TOKEN_PARSER6_error, std::move (l));
 
 1944#if 201103L <= YY_CPLUSPLUS 
 1947      make_PARSER6_UNDEF (location_type l)
 
 1949        return symbol_type (token::TOKEN_PARSER6_UNDEF, std::move (l));
 
 1959#if 201103L <= YY_CPLUSPLUS 
 1962      make_COMMA (location_type l)
 
 1964        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1974#if 201103L <= YY_CPLUSPLUS 
 1977      make_COLON (location_type l)
 
 1979        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1989#if 201103L <= YY_CPLUSPLUS 
 1992      make_LSQUARE_BRACKET (location_type l)
 
 1994        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 2004#if 201103L <= YY_CPLUSPLUS 
 2007      make_RSQUARE_BRACKET (location_type l)
 
 2009        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 2019#if 201103L <= YY_CPLUSPLUS 
 2022      make_LCURLY_BRACKET (location_type l)
 
 2024        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 2034#if 201103L <= YY_CPLUSPLUS 
 2037      make_RCURLY_BRACKET (location_type l)
 
 2039        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 2049#if 201103L <= YY_CPLUSPLUS 
 2052      make_NULL_TYPE (location_type l)
 
 2054        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 2064#if 201103L <= YY_CPLUSPLUS 
 2067      make_DHCP6 (location_type l)
 
 2069        return symbol_type (token::TOKEN_DHCP6, std::move (l));
 
 2079#if 201103L <= YY_CPLUSPLUS 
 2082      make_DATA_DIRECTORY (location_type l)
 
 2084        return symbol_type (token::TOKEN_DATA_DIRECTORY, std::move (l));
 
 2094#if 201103L <= YY_CPLUSPLUS 
 2097      make_CONFIG_CONTROL (location_type l)
 
 2099        return symbol_type (token::TOKEN_CONFIG_CONTROL, std::move (l));
 
 2109#if 201103L <= YY_CPLUSPLUS 
 2112      make_CONFIG_DATABASES (location_type l)
 
 2114        return symbol_type (token::TOKEN_CONFIG_DATABASES, std::move (l));
 
 2124#if 201103L <= YY_CPLUSPLUS 
 2127      make_CONFIG_FETCH_WAIT_TIME (location_type l)
 
 2129        return symbol_type (token::TOKEN_CONFIG_FETCH_WAIT_TIME, std::move (l));
 
 2139#if 201103L <= YY_CPLUSPLUS 
 2142      make_INTERFACES_CONFIG (location_type l)
 
 2144        return symbol_type (token::TOKEN_INTERFACES_CONFIG, std::move (l));
 
 2154#if 201103L <= YY_CPLUSPLUS 
 2157      make_INTERFACES (location_type l)
 
 2159        return symbol_type (token::TOKEN_INTERFACES, std::move (l));
 
 2169#if 201103L <= YY_CPLUSPLUS 
 2172      make_RE_DETECT (location_type l)
 
 2174        return symbol_type (token::TOKEN_RE_DETECT, std::move (l));
 
 2184#if 201103L <= YY_CPLUSPLUS 
 2187      make_SERVICE_SOCKETS_REQUIRE_ALL (location_type l)
 
 2189        return symbol_type (token::TOKEN_SERVICE_SOCKETS_REQUIRE_ALL, std::move (l));
 
 2199#if 201103L <= YY_CPLUSPLUS 
 2202      make_SERVICE_SOCKETS_RETRY_WAIT_TIME (location_type l)
 
 2204        return symbol_type (token::TOKEN_SERVICE_SOCKETS_RETRY_WAIT_TIME, std::move (l));
 
 2214#if 201103L <= YY_CPLUSPLUS 
 2217      make_SERVICE_SOCKETS_MAX_RETRIES (location_type l)
 
 2219        return symbol_type (token::TOKEN_SERVICE_SOCKETS_MAX_RETRIES, std::move (l));
 
 2229#if 201103L <= YY_CPLUSPLUS 
 2232      make_LEASE_DATABASE (location_type l)
 
 2234        return symbol_type (token::TOKEN_LEASE_DATABASE, std::move (l));
 
 2244#if 201103L <= YY_CPLUSPLUS 
 2247      make_HOSTS_DATABASE (location_type l)
 
 2249        return symbol_type (token::TOKEN_HOSTS_DATABASE, std::move (l));
 
 2259#if 201103L <= YY_CPLUSPLUS 
 2262      make_HOSTS_DATABASES (location_type l)
 
 2264        return symbol_type (token::TOKEN_HOSTS_DATABASES, std::move (l));
 
 2274#if 201103L <= YY_CPLUSPLUS 
 2277      make_TYPE (location_type l)
 
 2279        return symbol_type (token::TOKEN_TYPE, std::move (l));
 
 2289#if 201103L <= YY_CPLUSPLUS 
 2292      make_USER (location_type l)
 
 2294        return symbol_type (token::TOKEN_USER, std::move (l));
 
 2304#if 201103L <= YY_CPLUSPLUS 
 2307      make_PASSWORD (location_type l)
 
 2309        return symbol_type (token::TOKEN_PASSWORD, std::move (l));
 
 2319#if 201103L <= YY_CPLUSPLUS 
 2322      make_HOST (location_type l)
 
 2324        return symbol_type (token::TOKEN_HOST, std::move (l));
 
 2334#if 201103L <= YY_CPLUSPLUS 
 2337      make_PORT (location_type l)
 
 2339        return symbol_type (token::TOKEN_PORT, std::move (l));
 
 2349#if 201103L <= YY_CPLUSPLUS 
 2352      make_PERSIST (location_type l)
 
 2354        return symbol_type (token::TOKEN_PERSIST, std::move (l));
 
 2364#if 201103L <= YY_CPLUSPLUS 
 2367      make_LFC_INTERVAL (location_type l)
 
 2369        return symbol_type (token::TOKEN_LFC_INTERVAL, std::move (l));
 
 2379#if 201103L <= YY_CPLUSPLUS 
 2382      make_READONLY (location_type l)
 
 2384        return symbol_type (token::TOKEN_READONLY, std::move (l));
 
 2394#if 201103L <= YY_CPLUSPLUS 
 2397      make_CONNECT_TIMEOUT (location_type l)
 
 2399        return symbol_type (token::TOKEN_CONNECT_TIMEOUT, std::move (l));
 
 2409#if 201103L <= YY_CPLUSPLUS 
 2412      make_READ_TIMEOUT (location_type l)
 
 2414        return symbol_type (token::TOKEN_READ_TIMEOUT, std::move (l));
 
 2424#if 201103L <= YY_CPLUSPLUS 
 2427      make_WRITE_TIMEOUT (location_type l)
 
 2429        return symbol_type (token::TOKEN_WRITE_TIMEOUT, std::move (l));
 
 2439#if 201103L <= YY_CPLUSPLUS 
 2442      make_TCP_USER_TIMEOUT (location_type l)
 
 2444        return symbol_type (token::TOKEN_TCP_USER_TIMEOUT, std::move (l));
 
 2454#if 201103L <= YY_CPLUSPLUS 
 2457      make_MAX_RECONNECT_TRIES (location_type l)
 
 2459        return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, std::move (l));
 
 2469#if 201103L <= YY_CPLUSPLUS 
 2472      make_RECONNECT_WAIT_TIME (location_type l)
 
 2474        return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, std::move (l));
 
 2484#if 201103L <= YY_CPLUSPLUS 
 2487      make_ON_FAIL (location_type l)
 
 2489        return symbol_type (token::TOKEN_ON_FAIL, std::move (l));
 
 2499#if 201103L <= YY_CPLUSPLUS 
 2502      make_STOP_RETRY_EXIT (location_type l)
 
 2504        return symbol_type (token::TOKEN_STOP_RETRY_EXIT, std::move (l));
 
 2514#if 201103L <= YY_CPLUSPLUS 
 2517      make_SERVE_RETRY_EXIT (location_type l)
 
 2519        return symbol_type (token::TOKEN_SERVE_RETRY_EXIT, std::move (l));
 
 2529#if 201103L <= YY_CPLUSPLUS 
 2532      make_SERVE_RETRY_CONTINUE (location_type l)
 
 2534        return symbol_type (token::TOKEN_SERVE_RETRY_CONTINUE, std::move (l));
 
 2544#if 201103L <= YY_CPLUSPLUS 
 2547      make_RETRY_ON_STARTUP (location_type l)
 
 2549        return symbol_type (token::TOKEN_RETRY_ON_STARTUP, std::move (l));
 
 2559#if 201103L <= YY_CPLUSPLUS 
 2562      make_MAX_ROW_ERRORS (location_type l)
 
 2564        return symbol_type (token::TOKEN_MAX_ROW_ERRORS, std::move (l));
 
 2574#if 201103L <= YY_CPLUSPLUS 
 2577      make_TRUST_ANCHOR (location_type l)
 
 2579        return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
 
 2589#if 201103L <= YY_CPLUSPLUS 
 2592      make_CERT_FILE (location_type l)
 
 2594        return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
 
 2604#if 201103L <= YY_CPLUSPLUS 
 2607      make_KEY_FILE (location_type l)
 
 2609        return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
 
 2619#if 201103L <= YY_CPLUSPLUS 
 2622      make_SSL_MODE (location_type l)
 
 2624        return symbol_type (token::TOKEN_SSL_MODE, std::move (l));
 
 2634#if 201103L <= YY_CPLUSPLUS 
 2637      make_DISABLE (location_type l)
 
 2639        return symbol_type (token::TOKEN_DISABLE, std::move (l));
 
 2649#if 201103L <= YY_CPLUSPLUS 
 2652      make_PREFER (location_type l)
 
 2654        return symbol_type (token::TOKEN_PREFER, std::move (l));
 
 2664#if 201103L <= YY_CPLUSPLUS 
 2667      make_REQUIRE (location_type l)
 
 2669        return symbol_type (token::TOKEN_REQUIRE, std::move (l));
 
 2679#if 201103L <= YY_CPLUSPLUS 
 2682      make_VERIFY_CA (location_type l)
 
 2684        return symbol_type (token::TOKEN_VERIFY_CA, std::move (l));
 
 2694#if 201103L <= YY_CPLUSPLUS 
 2697      make_VERIFY_FULL (location_type l)
 
 2699        return symbol_type (token::TOKEN_VERIFY_FULL, std::move (l));
 
 2709#if 201103L <= YY_CPLUSPLUS 
 2712      make_CIPHER_LIST (location_type l)
 
 2714        return symbol_type (token::TOKEN_CIPHER_LIST, std::move (l));
 
 2724#if 201103L <= YY_CPLUSPLUS 
 2727      make_PREFERRED_LIFETIME (location_type l)
 
 2729        return symbol_type (token::TOKEN_PREFERRED_LIFETIME, std::move (l));
 
 2739#if 201103L <= YY_CPLUSPLUS 
 2742      make_MIN_PREFERRED_LIFETIME (location_type l)
 
 2744        return symbol_type (token::TOKEN_MIN_PREFERRED_LIFETIME, std::move (l));
 
 2754#if 201103L <= YY_CPLUSPLUS 
 2757      make_MAX_PREFERRED_LIFETIME (location_type l)
 
 2759        return symbol_type (token::TOKEN_MAX_PREFERRED_LIFETIME, std::move (l));
 
 2769#if 201103L <= YY_CPLUSPLUS 
 2772      make_VALID_LIFETIME (location_type l)
 
 2774        return symbol_type (token::TOKEN_VALID_LIFETIME, std::move (l));
 
 2784#if 201103L <= YY_CPLUSPLUS 
 2787      make_MIN_VALID_LIFETIME (location_type l)
 
 2789        return symbol_type (token::TOKEN_MIN_VALID_LIFETIME, std::move (l));
 
 2799#if 201103L <= YY_CPLUSPLUS 
 2802      make_MAX_VALID_LIFETIME (location_type l)
 
 2804        return symbol_type (token::TOKEN_MAX_VALID_LIFETIME, std::move (l));
 
 2814#if 201103L <= YY_CPLUSPLUS 
 2817      make_RENEW_TIMER (location_type l)
 
 2819        return symbol_type (token::TOKEN_RENEW_TIMER, std::move (l));
 
 2829#if 201103L <= YY_CPLUSPLUS 
 2832      make_REBIND_TIMER (location_type l)
 
 2834        return symbol_type (token::TOKEN_REBIND_TIMER, std::move (l));
 
 2844#if 201103L <= YY_CPLUSPLUS 
 2847      make_CALCULATE_TEE_TIMES (location_type l)
 
 2849        return symbol_type (token::TOKEN_CALCULATE_TEE_TIMES, std::move (l));
 
 2859#if 201103L <= YY_CPLUSPLUS 
 2862      make_T1_PERCENT (location_type l)
 
 2864        return symbol_type (token::TOKEN_T1_PERCENT, std::move (l));
 
 2874#if 201103L <= YY_CPLUSPLUS 
 2877      make_T2_PERCENT (location_type l)
 
 2879        return symbol_type (token::TOKEN_T2_PERCENT, std::move (l));
 
 2889#if 201103L <= YY_CPLUSPLUS 
 2892      make_CACHE_THRESHOLD (location_type l)
 
 2894        return symbol_type (token::TOKEN_CACHE_THRESHOLD, std::move (l));
 
 2904#if 201103L <= YY_CPLUSPLUS 
 2907      make_CACHE_MAX_AGE (location_type l)
 
 2909        return symbol_type (token::TOKEN_CACHE_MAX_AGE, std::move (l));
 
 2919#if 201103L <= YY_CPLUSPLUS 
 2922      make_DECLINE_PROBATION_PERIOD (location_type l)
 
 2924        return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, std::move (l));
 
 2934#if 201103L <= YY_CPLUSPLUS 
 2937      make_SERVER_TAG (location_type l)
 
 2939        return symbol_type (token::TOKEN_SERVER_TAG, std::move (l));
 
 2949#if 201103L <= YY_CPLUSPLUS 
 2952      make_STATISTIC_DEFAULT_SAMPLE_COUNT (location_type l)
 
 2954        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT, std::move (l));
 
 2964#if 201103L <= YY_CPLUSPLUS 
 2967      make_STATISTIC_DEFAULT_SAMPLE_AGE (location_type l)
 
 2969        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE, std::move (l));
 
 2979#if 201103L <= YY_CPLUSPLUS 
 2982      make_DDNS_SEND_UPDATES (location_type l)
 
 2984        return symbol_type (token::TOKEN_DDNS_SEND_UPDATES, std::move (l));
 
 2994#if 201103L <= YY_CPLUSPLUS 
 2997      make_DDNS_OVERRIDE_NO_UPDATE (location_type l)
 
 2999        return symbol_type (token::TOKEN_DDNS_OVERRIDE_NO_UPDATE, std::move (l));
 
 3009#if 201103L <= YY_CPLUSPLUS 
 3012      make_DDNS_OVERRIDE_CLIENT_UPDATE (location_type l)
 
 3014        return symbol_type (token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE, std::move (l));
 
 3024#if 201103L <= YY_CPLUSPLUS 
 3027      make_DDNS_REPLACE_CLIENT_NAME (location_type l)
 
 3029        return symbol_type (token::TOKEN_DDNS_REPLACE_CLIENT_NAME, std::move (l));
 
 3039#if 201103L <= YY_CPLUSPLUS 
 3042      make_DDNS_GENERATED_PREFIX (location_type l)
 
 3044        return symbol_type (token::TOKEN_DDNS_GENERATED_PREFIX, std::move (l));
 
 3054#if 201103L <= YY_CPLUSPLUS 
 3057      make_DDNS_QUALIFYING_SUFFIX (location_type l)
 
 3059        return symbol_type (token::TOKEN_DDNS_QUALIFYING_SUFFIX, std::move (l));
 
 3069#if 201103L <= YY_CPLUSPLUS 
 3072      make_DDNS_UPDATE_ON_RENEW (location_type l)
 
 3074        return symbol_type (token::TOKEN_DDNS_UPDATE_ON_RENEW, std::move (l));
 
 3084#if 201103L <= YY_CPLUSPLUS 
 3087      make_DDNS_USE_CONFLICT_RESOLUTION (location_type l)
 
 3089        return symbol_type (token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION, std::move (l));
 
 3099#if 201103L <= YY_CPLUSPLUS 
 3102      make_DDNS_TTL_PERCENT (location_type l)
 
 3104        return symbol_type (token::TOKEN_DDNS_TTL_PERCENT, std::move (l));
 
 3114#if 201103L <= YY_CPLUSPLUS 
 3117      make_DDNS_TTL (location_type l)
 
 3119        return symbol_type (token::TOKEN_DDNS_TTL, std::move (l));
 
 3129#if 201103L <= YY_CPLUSPLUS 
 3132      make_DDNS_TTL_MIN (location_type l)
 
 3134        return symbol_type (token::TOKEN_DDNS_TTL_MIN, std::move (l));
 
 3144#if 201103L <= YY_CPLUSPLUS 
 3147      make_DDNS_TTL_MAX (location_type l)
 
 3149        return symbol_type (token::TOKEN_DDNS_TTL_MAX, std::move (l));
 
 3159#if 201103L <= YY_CPLUSPLUS 
 3162      make_STORE_EXTENDED_INFO (location_type l)
 
 3164        return symbol_type (token::TOKEN_STORE_EXTENDED_INFO, std::move (l));
 
 3174#if 201103L <= YY_CPLUSPLUS 
 3177      make_SUBNET6 (location_type l)
 
 3179        return symbol_type (token::TOKEN_SUBNET6, std::move (l));
 
 3189#if 201103L <= YY_CPLUSPLUS 
 3192      make_OPTION_DEF (location_type l)
 
 3194        return symbol_type (token::TOKEN_OPTION_DEF, std::move (l));
 
 3204#if 201103L <= YY_CPLUSPLUS 
 3207      make_OPTION_DATA (location_type l)
 
 3209        return symbol_type (token::TOKEN_OPTION_DATA, std::move (l));
 
 3219#if 201103L <= YY_CPLUSPLUS 
 3222      make_NAME (location_type l)
 
 3224        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 3234#if 201103L <= YY_CPLUSPLUS 
 3237      make_DATA (location_type l)
 
 3239        return symbol_type (token::TOKEN_DATA, std::move (l));
 
 3249#if 201103L <= YY_CPLUSPLUS 
 3252      make_CODE (location_type l)
 
 3254        return symbol_type (token::TOKEN_CODE, std::move (l));
 
 3264#if 201103L <= YY_CPLUSPLUS 
 3267      make_SPACE (location_type l)
 
 3269        return symbol_type (token::TOKEN_SPACE, std::move (l));
 
 3279#if 201103L <= YY_CPLUSPLUS 
 3282      make_CSV_FORMAT (location_type l)
 
 3284        return symbol_type (token::TOKEN_CSV_FORMAT, std::move (l));
 
 3294#if 201103L <= YY_CPLUSPLUS 
 3297      make_ALWAYS_SEND (location_type l)
 
 3299        return symbol_type (token::TOKEN_ALWAYS_SEND, std::move (l));
 
 3309#if 201103L <= YY_CPLUSPLUS 
 3312      make_NEVER_SEND (location_type l)
 
 3314        return symbol_type (token::TOKEN_NEVER_SEND, std::move (l));
 
 3324#if 201103L <= YY_CPLUSPLUS 
 3327      make_RECORD_TYPES (location_type l)
 
 3329        return symbol_type (token::TOKEN_RECORD_TYPES, std::move (l));
 
 3339#if 201103L <= YY_CPLUSPLUS 
 3342      make_ENCAPSULATE (location_type l)
 
 3344        return symbol_type (token::TOKEN_ENCAPSULATE, std::move (l));
 
 3354#if 201103L <= YY_CPLUSPLUS 
 3357      make_ARRAY (location_type l)
 
 3359        return symbol_type (token::TOKEN_ARRAY, std::move (l));
 
 3369#if 201103L <= YY_CPLUSPLUS 
 3372      make_PARKED_PACKET_LIMIT (location_type l)
 
 3374        return symbol_type (token::TOKEN_PARKED_PACKET_LIMIT, std::move (l));
 
 3384#if 201103L <= YY_CPLUSPLUS 
 3387      make_ALLOCATOR (location_type l)
 
 3389        return symbol_type (token::TOKEN_ALLOCATOR, std::move (l));
 
 3399#if 201103L <= YY_CPLUSPLUS 
 3402      make_PD_ALLOCATOR (location_type l)
 
 3404        return symbol_type (token::TOKEN_PD_ALLOCATOR, std::move (l));
 
 3414#if 201103L <= YY_CPLUSPLUS 
 3417      make_DDNS_CONFLICT_RESOLUTION_MODE (location_type l)
 
 3419        return symbol_type (token::TOKEN_DDNS_CONFLICT_RESOLUTION_MODE, std::move (l));
 
 3429#if 201103L <= YY_CPLUSPLUS 
 3432      make_CHECK_WITH_DHCID (location_type l)
 
 3434        return symbol_type (token::TOKEN_CHECK_WITH_DHCID, std::move (l));
 
 3444#if 201103L <= YY_CPLUSPLUS 
 3447      make_NO_CHECK_WITH_DHCID (location_type l)
 
 3449        return symbol_type (token::TOKEN_NO_CHECK_WITH_DHCID, std::move (l));
 
 3459#if 201103L <= YY_CPLUSPLUS 
 3462      make_CHECK_EXISTS_WITH_DHCID (location_type l)
 
 3464        return symbol_type (token::TOKEN_CHECK_EXISTS_WITH_DHCID, std::move (l));
 
 3474#if 201103L <= YY_CPLUSPLUS 
 3477      make_NO_CHECK_WITHOUT_DHCID (location_type l)
 
 3479        return symbol_type (token::TOKEN_NO_CHECK_WITHOUT_DHCID, std::move (l));
 
 3489#if 201103L <= YY_CPLUSPLUS 
 3492      make_SHARED_NETWORKS (location_type l)
 
 3494        return symbol_type (token::TOKEN_SHARED_NETWORKS, std::move (l));
 
 3504#if 201103L <= YY_CPLUSPLUS 
 3507      make_POOLS (location_type l)
 
 3509        return symbol_type (token::TOKEN_POOLS, std::move (l));
 
 3519#if 201103L <= YY_CPLUSPLUS 
 3522      make_POOL (location_type l)
 
 3524        return symbol_type (token::TOKEN_POOL, std::move (l));
 
 3534#if 201103L <= YY_CPLUSPLUS 
 3537      make_PD_POOLS (location_type l)
 
 3539        return symbol_type (token::TOKEN_PD_POOLS, std::move (l));
 
 3549#if 201103L <= YY_CPLUSPLUS 
 3552      make_PREFIX (location_type l)
 
 3554        return symbol_type (token::TOKEN_PREFIX, std::move (l));
 
 3564#if 201103L <= YY_CPLUSPLUS 
 3567      make_PREFIX_LEN (location_type l)
 
 3569        return symbol_type (token::TOKEN_PREFIX_LEN, std::move (l));
 
 3579#if 201103L <= YY_CPLUSPLUS 
 3582      make_EXCLUDED_PREFIX (location_type l)
 
 3584        return symbol_type (token::TOKEN_EXCLUDED_PREFIX, std::move (l));
 
 3594#if 201103L <= YY_CPLUSPLUS 
 3597      make_EXCLUDED_PREFIX_LEN (location_type l)
 
 3599        return symbol_type (token::TOKEN_EXCLUDED_PREFIX_LEN, std::move (l));
 
 3609#if 201103L <= YY_CPLUSPLUS 
 3612      make_DELEGATED_LEN (location_type l)
 
 3614        return symbol_type (token::TOKEN_DELEGATED_LEN, std::move (l));
 
 3624#if 201103L <= YY_CPLUSPLUS 
 3627      make_USER_CONTEXT (location_type l)
 
 3629        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 3639#if 201103L <= YY_CPLUSPLUS 
 3642      make_COMMENT (location_type l)
 
 3644        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 3654#if 201103L <= YY_CPLUSPLUS 
 3657      make_SUBNET (location_type l)
 
 3659        return symbol_type (token::TOKEN_SUBNET, std::move (l));
 
 3669#if 201103L <= YY_CPLUSPLUS 
 3672      make_INTERFACE (location_type l)
 
 3674        return symbol_type (token::TOKEN_INTERFACE, std::move (l));
 
 3684#if 201103L <= YY_CPLUSPLUS 
 3687      make_INTERFACE_ID (location_type l)
 
 3689        return symbol_type (token::TOKEN_INTERFACE_ID, std::move (l));
 
 3699#if 201103L <= YY_CPLUSPLUS 
 3702      make_ID (location_type l)
 
 3704        return symbol_type (token::TOKEN_ID, std::move (l));
 
 3714#if 201103L <= YY_CPLUSPLUS 
 3717      make_RAPID_COMMIT (location_type l)
 
 3719        return symbol_type (token::TOKEN_RAPID_COMMIT, std::move (l));
 
 3729#if 201103L <= YY_CPLUSPLUS 
 3732      make_RESERVATIONS_GLOBAL (location_type l)
 
 3734        return symbol_type (token::TOKEN_RESERVATIONS_GLOBAL, std::move (l));
 
 3744#if 201103L <= YY_CPLUSPLUS 
 3747      make_RESERVATIONS_IN_SUBNET (location_type l)
 
 3749        return symbol_type (token::TOKEN_RESERVATIONS_IN_SUBNET, std::move (l));
 
 3759#if 201103L <= YY_CPLUSPLUS 
 3762      make_RESERVATIONS_OUT_OF_POOL (location_type l)
 
 3764        return symbol_type (token::TOKEN_RESERVATIONS_OUT_OF_POOL, std::move (l));
 
 3774#if 201103L <= YY_CPLUSPLUS 
 3777      make_MAC_SOURCES (location_type l)
 
 3779        return symbol_type (token::TOKEN_MAC_SOURCES, std::move (l));
 
 3789#if 201103L <= YY_CPLUSPLUS 
 3792      make_RELAY_SUPPLIED_OPTIONS (location_type l)
 
 3794        return symbol_type (token::TOKEN_RELAY_SUPPLIED_OPTIONS, std::move (l));
 
 3804#if 201103L <= YY_CPLUSPLUS 
 3807      make_HOST_RESERVATION_IDENTIFIERS (location_type l)
 
 3809        return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, std::move (l));
 
 3819#if 201103L <= YY_CPLUSPLUS 
 3822      make_SANITY_CHECKS (location_type l)
 
 3824        return symbol_type (token::TOKEN_SANITY_CHECKS, std::move (l));
 
 3834#if 201103L <= YY_CPLUSPLUS 
 3837      make_LEASE_CHECKS (location_type l)
 
 3839        return symbol_type (token::TOKEN_LEASE_CHECKS, std::move (l));
 
 3849#if 201103L <= YY_CPLUSPLUS 
 3852      make_EXTENDED_INFO_CHECKS (location_type l)
 
 3854        return symbol_type (token::TOKEN_EXTENDED_INFO_CHECKS, std::move (l));
 
 3864#if 201103L <= YY_CPLUSPLUS 
 3867      make_CLIENT_CLASSES (location_type l)
 
 3869        return symbol_type (token::TOKEN_CLIENT_CLASSES, std::move (l));
 
 3879#if 201103L <= YY_CPLUSPLUS 
 3882      make_REQUIRE_CLIENT_CLASSES (location_type l)
 
 3884        return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, std::move (l));
 
 3894#if 201103L <= YY_CPLUSPLUS 
 3897      make_EVALUATE_ADDITIONAL_CLASSES (location_type l)
 
 3899        return symbol_type (token::TOKEN_EVALUATE_ADDITIONAL_CLASSES, std::move (l));
 
 3909#if 201103L <= YY_CPLUSPLUS 
 3912      make_TEST (location_type l)
 
 3914        return symbol_type (token::TOKEN_TEST, std::move (l));
 
 3924#if 201103L <= YY_CPLUSPLUS 
 3927      make_TEMPLATE_TEST (location_type l)
 
 3929        return symbol_type (token::TOKEN_TEMPLATE_TEST, std::move (l));
 
 3939#if 201103L <= YY_CPLUSPLUS 
 3942      make_ONLY_IF_REQUIRED (location_type l)
 
 3944        return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, std::move (l));
 
 3954#if 201103L <= YY_CPLUSPLUS 
 3957      make_ONLY_IN_ADDITIONAL_LIST (location_type l)
 
 3959        return symbol_type (token::TOKEN_ONLY_IN_ADDITIONAL_LIST, std::move (l));
 
 3969#if 201103L <= YY_CPLUSPLUS 
 3972      make_CLIENT_CLASS (location_type l)
 
 3974        return symbol_type (token::TOKEN_CLIENT_CLASS, std::move (l));
 
 3984#if 201103L <= YY_CPLUSPLUS 
 3987      make_POOL_ID (location_type l)
 
 3989        return symbol_type (token::TOKEN_POOL_ID, std::move (l));
 
 3999#if 201103L <= YY_CPLUSPLUS 
 4002      make_RESERVATIONS (location_type l)
 
 4004        return symbol_type (token::TOKEN_RESERVATIONS, std::move (l));
 
 4014#if 201103L <= YY_CPLUSPLUS 
 4017      make_IP_ADDRESSES (location_type l)
 
 4019        return symbol_type (token::TOKEN_IP_ADDRESSES, std::move (l));
 
 4029#if 201103L <= YY_CPLUSPLUS 
 4032      make_PREFIXES (location_type l)
 
 4034        return symbol_type (token::TOKEN_PREFIXES, std::move (l));
 
 4044#if 201103L <= YY_CPLUSPLUS 
 4047      make_EXCLUDED_PREFIXES (location_type l)
 
 4049        return symbol_type (token::TOKEN_EXCLUDED_PREFIXES, std::move (l));
 
 4059#if 201103L <= YY_CPLUSPLUS 
 4062      make_DUID (location_type l)
 
 4064        return symbol_type (token::TOKEN_DUID, std::move (l));
 
 4074#if 201103L <= YY_CPLUSPLUS 
 4077      make_HW_ADDRESS (location_type l)
 
 4079        return symbol_type (token::TOKEN_HW_ADDRESS, std::move (l));
 
 4089#if 201103L <= YY_CPLUSPLUS 
 4092      make_HOSTNAME (location_type l)
 
 4094        return symbol_type (token::TOKEN_HOSTNAME, std::move (l));
 
 4104#if 201103L <= YY_CPLUSPLUS 
 4107      make_FLEX_ID (location_type l)
 
 4109        return symbol_type (token::TOKEN_FLEX_ID, std::move (l));
 
 4119#if 201103L <= YY_CPLUSPLUS 
 4122      make_RELAY (location_type l)
 
 4124        return symbol_type (token::TOKEN_RELAY, std::move (l));
 
 4134#if 201103L <= YY_CPLUSPLUS 
 4137      make_HOOKS_LIBRARIES (location_type l)
 
 4139        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 4149#if 201103L <= YY_CPLUSPLUS 
 4152      make_LIBRARY (location_type l)
 
 4154        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 4164#if 201103L <= YY_CPLUSPLUS 
 4167      make_PARAMETERS (location_type l)
 
 4169        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 4179#if 201103L <= YY_CPLUSPLUS 
 4182      make_EXPIRED_LEASES_PROCESSING (location_type l)
 
 4184        return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, std::move (l));
 
 4194#if 201103L <= YY_CPLUSPLUS 
 4197      make_RECLAIM_TIMER_WAIT_TIME (location_type l)
 
 4199        return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, std::move (l));
 
 4209#if 201103L <= YY_CPLUSPLUS 
 4212      make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (location_type l)
 
 4214        return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, std::move (l));
 
 4224#if 201103L <= YY_CPLUSPLUS 
 4227      make_HOLD_RECLAIMED_TIME (location_type l)
 
 4229        return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, std::move (l));
 
 4239#if 201103L <= YY_CPLUSPLUS 
 4242      make_MAX_RECLAIM_LEASES (location_type l)
 
 4244        return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, std::move (l));
 
 4254#if 201103L <= YY_CPLUSPLUS 
 4257      make_MAX_RECLAIM_TIME (location_type l)
 
 4259        return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, std::move (l));
 
 4269#if 201103L <= YY_CPLUSPLUS 
 4272      make_UNWARNED_RECLAIM_CYCLES (location_type l)
 
 4274        return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, std::move (l));
 
 4284#if 201103L <= YY_CPLUSPLUS 
 4287      make_SERVER_ID (location_type l)
 
 4289        return symbol_type (token::TOKEN_SERVER_ID, std::move (l));
 
 4299#if 201103L <= YY_CPLUSPLUS 
 4302      make_LLT (location_type l)
 
 4304        return symbol_type (token::TOKEN_LLT, std::move (l));
 
 4314#if 201103L <= YY_CPLUSPLUS 
 4317      make_EN (location_type l)
 
 4319        return symbol_type (token::TOKEN_EN, std::move (l));
 
 4329#if 201103L <= YY_CPLUSPLUS 
 4332      make_LL (location_type l)
 
 4334        return symbol_type (token::TOKEN_LL, std::move (l));
 
 4344#if 201103L <= YY_CPLUSPLUS 
 4347      make_IDENTIFIER (location_type l)
 
 4349        return symbol_type (token::TOKEN_IDENTIFIER, std::move (l));
 
 4359#if 201103L <= YY_CPLUSPLUS 
 4362      make_HTYPE (location_type l)
 
 4364        return symbol_type (token::TOKEN_HTYPE, std::move (l));
 
 4374#if 201103L <= YY_CPLUSPLUS 
 4377      make_TIME (location_type l)
 
 4379        return symbol_type (token::TOKEN_TIME, std::move (l));
 
 4389#if 201103L <= YY_CPLUSPLUS 
 4392      make_ENTERPRISE_ID (location_type l)
 
 4394        return symbol_type (token::TOKEN_ENTERPRISE_ID, std::move (l));
 
 4404#if 201103L <= YY_CPLUSPLUS 
 4407      make_DHCP4O6_PORT (location_type l)
 
 4409        return symbol_type (token::TOKEN_DHCP4O6_PORT, std::move (l));
 
 4419#if 201103L <= YY_CPLUSPLUS 
 4422      make_DHCP_MULTI_THREADING (location_type l)
 
 4424        return symbol_type (token::TOKEN_DHCP_MULTI_THREADING, std::move (l));
 
 4434#if 201103L <= YY_CPLUSPLUS 
 4437      make_ENABLE_MULTI_THREADING (location_type l)
 
 4439        return symbol_type (token::TOKEN_ENABLE_MULTI_THREADING, std::move (l));
 
 4449#if 201103L <= YY_CPLUSPLUS 
 4452      make_THREAD_POOL_SIZE (location_type l)
 
 4454        return symbol_type (token::TOKEN_THREAD_POOL_SIZE, std::move (l));
 
 4464#if 201103L <= YY_CPLUSPLUS 
 4467      make_PACKET_QUEUE_SIZE (location_type l)
 
 4469        return symbol_type (token::TOKEN_PACKET_QUEUE_SIZE, std::move (l));
 
 4479#if 201103L <= YY_CPLUSPLUS 
 4482      make_CONTROL_SOCKET (location_type l)
 
 4484        return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
 
 4494#if 201103L <= YY_CPLUSPLUS 
 4497      make_CONTROL_SOCKETS (location_type l)
 
 4499        return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
 
 4509#if 201103L <= YY_CPLUSPLUS 
 4512      make_SOCKET_TYPE (location_type l)
 
 4514        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 4524#if 201103L <= YY_CPLUSPLUS 
 4527      make_UNIX (location_type l)
 
 4529        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 4539#if 201103L <= YY_CPLUSPLUS 
 4542      make_HTTP (location_type l)
 
 4544        return symbol_type (token::TOKEN_HTTP, std::move (l));
 
 4554#if 201103L <= YY_CPLUSPLUS 
 4557      make_HTTPS (location_type l)
 
 4559        return symbol_type (token::TOKEN_HTTPS, std::move (l));
 
 4569#if 201103L <= YY_CPLUSPLUS 
 4572      make_SOCKET_NAME (location_type l)
 
 4574        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 4584#if 201103L <= YY_CPLUSPLUS 
 4587      make_SOCKET_ADDRESS (location_type l)
 
 4589        return symbol_type (token::TOKEN_SOCKET_ADDRESS, std::move (l));
 
 4599#if 201103L <= YY_CPLUSPLUS 
 4602      make_SOCKET_PORT (location_type l)
 
 4604        return symbol_type (token::TOKEN_SOCKET_PORT, std::move (l));
 
 4614#if 201103L <= YY_CPLUSPLUS 
 4617      make_AUTHENTICATION (location_type l)
 
 4619        return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
 
 4629#if 201103L <= YY_CPLUSPLUS 
 4632      make_BASIC (location_type l)
 
 4634        return symbol_type (token::TOKEN_BASIC, std::move (l));
 
 4644#if 201103L <= YY_CPLUSPLUS 
 4647      make_REALM (location_type l)
 
 4649        return symbol_type (token::TOKEN_REALM, std::move (l));
 
 4659#if 201103L <= YY_CPLUSPLUS 
 4662      make_DIRECTORY (location_type l)
 
 4664        return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
 
 4674#if 201103L <= YY_CPLUSPLUS 
 4677      make_CLIENTS (location_type l)
 
 4679        return symbol_type (token::TOKEN_CLIENTS, std::move (l));
 
 4689#if 201103L <= YY_CPLUSPLUS 
 4692      make_USER_FILE (location_type l)
 
 4694        return symbol_type (token::TOKEN_USER_FILE, std::move (l));
 
 4704#if 201103L <= YY_CPLUSPLUS 
 4707      make_PASSWORD_FILE (location_type l)
 
 4709        return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
 
 4719#if 201103L <= YY_CPLUSPLUS 
 4722      make_CERT_REQUIRED (location_type l)
 
 4724        return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
 
 4734#if 201103L <= YY_CPLUSPLUS 
 4737      make_HTTP_HEADERS (location_type l)
 
 4739        return symbol_type (token::TOKEN_HTTP_HEADERS, std::move (l));
 
 4749#if 201103L <= YY_CPLUSPLUS 
 4752      make_VALUE (location_type l)
 
 4754        return symbol_type (token::TOKEN_VALUE, std::move (l));
 
 4764#if 201103L <= YY_CPLUSPLUS 
 4767      make_DHCP_QUEUE_CONTROL (location_type l)
 
 4769        return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, std::move (l));
 
 4779#if 201103L <= YY_CPLUSPLUS 
 4782      make_ENABLE_QUEUE (location_type l)
 
 4784        return symbol_type (token::TOKEN_ENABLE_QUEUE, std::move (l));
 
 4794#if 201103L <= YY_CPLUSPLUS 
 4797      make_QUEUE_TYPE (location_type l)
 
 4799        return symbol_type (token::TOKEN_QUEUE_TYPE, std::move (l));
 
 4809#if 201103L <= YY_CPLUSPLUS 
 4812      make_CAPACITY (location_type l)
 
 4814        return symbol_type (token::TOKEN_CAPACITY, std::move (l));
 
 4824#if 201103L <= YY_CPLUSPLUS 
 4827      make_DHCP_DDNS (location_type l)
 
 4829        return symbol_type (token::TOKEN_DHCP_DDNS, std::move (l));
 
 4839#if 201103L <= YY_CPLUSPLUS 
 4842      make_ENABLE_UPDATES (location_type l)
 
 4844        return symbol_type (token::TOKEN_ENABLE_UPDATES, std::move (l));
 
 4854#if 201103L <= YY_CPLUSPLUS 
 4857      make_SERVER_IP (location_type l)
 
 4859        return symbol_type (token::TOKEN_SERVER_IP, std::move (l));
 
 4869#if 201103L <= YY_CPLUSPLUS 
 4872      make_SERVER_PORT (location_type l)
 
 4874        return symbol_type (token::TOKEN_SERVER_PORT, std::move (l));
 
 4884#if 201103L <= YY_CPLUSPLUS 
 4887      make_SENDER_IP (location_type l)
 
 4889        return symbol_type (token::TOKEN_SENDER_IP, std::move (l));
 
 4899#if 201103L <= YY_CPLUSPLUS 
 4902      make_SENDER_PORT (location_type l)
 
 4904        return symbol_type (token::TOKEN_SENDER_PORT, std::move (l));
 
 4914#if 201103L <= YY_CPLUSPLUS 
 4917      make_MAX_QUEUE_SIZE (location_type l)
 
 4919        return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, std::move (l));
 
 4929#if 201103L <= YY_CPLUSPLUS 
 4932      make_NCR_PROTOCOL (location_type l)
 
 4934        return symbol_type (token::TOKEN_NCR_PROTOCOL, std::move (l));
 
 4944#if 201103L <= YY_CPLUSPLUS 
 4947      make_NCR_FORMAT (location_type l)
 
 4949        return symbol_type (token::TOKEN_NCR_FORMAT, std::move (l));
 
 4959#if 201103L <= YY_CPLUSPLUS 
 4962      make_UDP (location_type l)
 
 4964        return symbol_type (token::TOKEN_UDP, std::move (l));
 
 4974#if 201103L <= YY_CPLUSPLUS 
 4977      make_TCP (location_type l)
 
 4979        return symbol_type (token::TOKEN_TCP, std::move (l));
 
 4989#if 201103L <= YY_CPLUSPLUS 
 4992      make_JSON (location_type l)
 
 4994        return symbol_type (token::TOKEN_JSON, std::move (l));
 
 5004#if 201103L <= YY_CPLUSPLUS 
 5007      make_WHEN_PRESENT (location_type l)
 
 5009        return symbol_type (token::TOKEN_WHEN_PRESENT, std::move (l));
 
 5019#if 201103L <= YY_CPLUSPLUS 
 5022      make_NEVER (location_type l)
 
 5024        return symbol_type (token::TOKEN_NEVER, std::move (l));
 
 5034#if 201103L <= YY_CPLUSPLUS 
 5037      make_ALWAYS (location_type l)
 
 5039        return symbol_type (token::TOKEN_ALWAYS, std::move (l));
 
 5049#if 201103L <= YY_CPLUSPLUS 
 5052      make_WHEN_NOT_PRESENT (location_type l)
 
 5054        return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, std::move (l));
 
 5064#if 201103L <= YY_CPLUSPLUS 
 5067      make_HOSTNAME_CHAR_SET (location_type l)
 
 5069        return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, std::move (l));
 
 5079#if 201103L <= YY_CPLUSPLUS 
 5082      make_HOSTNAME_CHAR_REPLACEMENT (location_type l)
 
 5084        return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, std::move (l));
 
 5094#if 201103L <= YY_CPLUSPLUS 
 5097      make_EARLY_GLOBAL_RESERVATIONS_LOOKUP (location_type l)
 
 5099        return symbol_type (token::TOKEN_EARLY_GLOBAL_RESERVATIONS_LOOKUP, std::move (l));
 
 5109#if 201103L <= YY_CPLUSPLUS 
 5112      make_IP_RESERVATIONS_UNIQUE (location_type l)
 
 5114        return symbol_type (token::TOKEN_IP_RESERVATIONS_UNIQUE, std::move (l));
 
 5124#if 201103L <= YY_CPLUSPLUS 
 5127      make_RESERVATIONS_LOOKUP_FIRST (location_type l)
 
 5129        return symbol_type (token::TOKEN_RESERVATIONS_LOOKUP_FIRST, std::move (l));
 
 5139#if 201103L <= YY_CPLUSPLUS 
 5142      make_LOGGERS (location_type l)
 
 5144        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 5154#if 201103L <= YY_CPLUSPLUS 
 5157      make_OUTPUT_OPTIONS (location_type l)
 
 5159        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 5169#if 201103L <= YY_CPLUSPLUS 
 5172      make_OUTPUT (location_type l)
 
 5174        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 5184#if 201103L <= YY_CPLUSPLUS 
 5187      make_DEBUGLEVEL (location_type l)
 
 5189        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 5199#if 201103L <= YY_CPLUSPLUS 
 5202      make_SEVERITY (location_type l)
 
 5204        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 5214#if 201103L <= YY_CPLUSPLUS 
 5217      make_FLUSH (location_type l)
 
 5219        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 5229#if 201103L <= YY_CPLUSPLUS 
 5232      make_MAXSIZE (location_type l)
 
 5234        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 5244#if 201103L <= YY_CPLUSPLUS 
 5247      make_MAXVER (location_type l)
 
 5249        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 5259#if 201103L <= YY_CPLUSPLUS 
 5262      make_PATTERN (location_type l)
 
 5264        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 5274#if 201103L <= YY_CPLUSPLUS 
 5277      make_COMPATIBILITY (location_type l)
 
 5279        return symbol_type (token::TOKEN_COMPATIBILITY, std::move (l));
 
 5289#if 201103L <= YY_CPLUSPLUS 
 5292      make_LENIENT_OPTION_PARSING (location_type l)
 
 5294        return symbol_type (token::TOKEN_LENIENT_OPTION_PARSING, std::move (l));
 
 5304#if 201103L <= YY_CPLUSPLUS 
 5307      make_TOPLEVEL_JSON (location_type l)
 
 5309        return symbol_type (token::TOKEN_TOPLEVEL_JSON, std::move (l));
 
 5319#if 201103L <= YY_CPLUSPLUS 
 5322      make_TOPLEVEL_DHCP6 (location_type l)
 
 5324        return symbol_type (token::TOKEN_TOPLEVEL_DHCP6, std::move (l));
 
 5334#if 201103L <= YY_CPLUSPLUS 
 5337      make_SUB_DHCP6 (location_type l)
 
 5339        return symbol_type (token::TOKEN_SUB_DHCP6, std::move (l));
 
 5349#if 201103L <= YY_CPLUSPLUS 
 5352      make_SUB_INTERFACES6 (location_type l)
 
 5354        return symbol_type (token::TOKEN_SUB_INTERFACES6, std::move (l));
 
 5364#if 201103L <= YY_CPLUSPLUS 
 5367      make_SUB_SUBNET6 (location_type l)
 
 5369        return symbol_type (token::TOKEN_SUB_SUBNET6, std::move (l));
 
 5379#if 201103L <= YY_CPLUSPLUS 
 5382      make_SUB_POOL6 (location_type l)
 
 5384        return symbol_type (token::TOKEN_SUB_POOL6, std::move (l));
 
 5394#if 201103L <= YY_CPLUSPLUS 
 5397      make_SUB_PD_POOL (location_type l)
 
 5399        return symbol_type (token::TOKEN_SUB_PD_POOL, std::move (l));
 
 5409#if 201103L <= YY_CPLUSPLUS 
 5412      make_SUB_RESERVATION (location_type l)
 
 5414        return symbol_type (token::TOKEN_SUB_RESERVATION, std::move (l));
 
 5424#if 201103L <= YY_CPLUSPLUS 
 5427      make_SUB_OPTION_DEFS (location_type l)
 
 5429        return symbol_type (token::TOKEN_SUB_OPTION_DEFS, std::move (l));
 
 5439#if 201103L <= YY_CPLUSPLUS 
 5442      make_SUB_OPTION_DEF (location_type l)
 
 5444        return symbol_type (token::TOKEN_SUB_OPTION_DEF, std::move (l));
 
 5454#if 201103L <= YY_CPLUSPLUS 
 5457      make_SUB_OPTION_DATA (location_type l)
 
 5459        return symbol_type (token::TOKEN_SUB_OPTION_DATA, std::move (l));
 
 5469#if 201103L <= YY_CPLUSPLUS 
 5472      make_SUB_HOOKS_LIBRARY (location_type l)
 
 5474        return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, std::move (l));
 
 5484#if 201103L <= YY_CPLUSPLUS 
 5487      make_SUB_DHCP_DDNS (location_type l)
 
 5489        return symbol_type (token::TOKEN_SUB_DHCP_DDNS, std::move (l));
 
 5499#if 201103L <= YY_CPLUSPLUS 
 5502      make_SUB_CONFIG_CONTROL (location_type l)
 
 5504        return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, std::move (l));
 
 5514#if 201103L <= YY_CPLUSPLUS 
 5517      make_STRING (std::string v, location_type l)
 
 5519        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 5529#if 201103L <= YY_CPLUSPLUS 
 5532      make_INTEGER (int64_t v, location_type l)
 
 5534        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 5544#if 201103L <= YY_CPLUSPLUS 
 5547      make_FLOAT (
double v, location_type l)
 
 5549        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 5559#if 201103L <= YY_CPLUSPLUS 
 5562      make_BOOLEAN (
bool v, location_type l)
 
 5564        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 5595#if YY_CPLUSPLUS < 201103L 
 5604    typedef short state_type;
 
 5607    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 5608                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 5612    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 5616    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 5620    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5624    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5626    static const short yypact_ninf_;
 
 5627    static const signed char yytable_ninf_;
 
 5632    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 5635    static std::string yytnamerr_ (
const char *yystr);
 
 5638    static const char* 
const yytname_[];
 
 5644    static const short yypact_[];
 
 5649    static const short yydefact_[];
 
 5652    static const short yypgoto_[];
 
 5655    static const short yydefgoto_[];
 
 5660    static const short yytable_[];
 
 5662    static const short yycheck_[];
 
 5666    static const short yystos_[];
 
 5669    static const short yyr1_[];
 
 5672    static const signed char yyr2_[];
 
 5677    static const short yyrline_[];
 
 5679    virtual void yy_reduce_print_ (
int r) 
const;
 
 5681    virtual void yy_stack_print_ () 
const;
 
 5686    std::ostream* yycdebug_;
 
 5691    template <
typename Base>
 
 5692    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 5699    template <
typename Base>
 
 5700    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 5710      typedef state_type kind_type;
 
 5722      void move (by_state& that);
 
 5730      enum { empty_state = 0 };
 
 5738    struct stack_symbol_type : basic_symbol<by_state>
 
 5741      typedef basic_symbol<by_state> super_type;
 
 5743      stack_symbol_type ();
 
 5745      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 5747      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 5748#if YY_CPLUSPLUS < 201103L 
 5751      stack_symbol_type& operator= (stack_symbol_type& that);
 
 5755      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 5760    template <
typename T, 
typename S = std::vector<T> >
 
 5765      typedef typename S::iterator iterator;
 
 5766      typedef typename S::const_iterator const_iterator;
 
 5767      typedef typename S::size_type size_type;
 
 5768      typedef typename std::ptrdiff_t index_type;
 
 5774#if 201103L <= YY_CPLUSPLUS 
 5776      stack (
const stack&) = 
delete;
 
 5778      stack& operator= (
const stack&) = 
delete;
 
 5785      operator[] (index_type i)
 const 
 5787        return seq_[size_type (size () - 1 - i)];
 
 5794      operator[] (index_type i)
 
 5796        return seq_[size_type (size () - 1 - i)];
 
 5805        seq_.push_back (T ());
 
 5806        operator[] (0).move (t);
 
 5828        return index_type (seq_.size ());
 
 5835        return seq_.begin ();
 
 5855        operator[] (index_type i)
 const 
 5857          return stack_[range_ - i];
 
 
 5861        const stack& stack_;
 
 
 5866#if YY_CPLUSPLUS < 201103L 
 5868      stack (
const stack&);
 
 5870      stack& operator= (
const stack&);
 
 5878    typedef stack<stack_symbol_type> stack_type;
 
 5881    stack_type yystack_;
 
 5888    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 5896    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);