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);
 
  440      char dummy2[
sizeof (bool)];
 
  443      char dummy3[
sizeof (double)];
 
  446      char dummy4[
sizeof (int64_t)];
 
  449      char dummy5[
sizeof (std::string)];
 
  453    enum { size = 
sizeof (union_type) };
 
  465    const std::type_info *yytypeid_;
 
 
  479        : std::runtime_error (m)
 
 
  484        : std::runtime_error (s.what ())
 
 
 
 1506    template <
typename Base>
 
 1518#if 201103L <= YY_CPLUSPLUS 
 1521        : Base (std::move (that))
 
 1523        , location (std::move (that.location))
 
 1525        switch (this->kind ())
 
 1536        value.move< 
ElementPtr > (std::move (that.value));
 
 1540        value.move< 
bool > (std::move (that.value));
 
 1544        value.move< 
double > (std::move (that.value));
 
 1548        value.move< int64_t > (std::move (that.value));
 
 1552        value.move< std::string > (std::move (that.value));
 
 1566#if 201103L <= YY_CPLUSPLUS 
 1578#if 201103L <= YY_CPLUSPLUS 
 1581        , value (std::move (v))
 
 1582        , location (std::move (l))
 
 1592#if 201103L <= YY_CPLUSPLUS 
 1595        , value (std::move (v))
 
 1596        , location (std::move (l))
 
 1606#if 201103L <= YY_CPLUSPLUS 
 1609        , value (std::move (v))
 
 1610        , location (std::move (l))
 
 1620#if 201103L <= YY_CPLUSPLUS 
 1623        , value (std::move (v))
 
 1624        , location (std::move (l))
 
 1634#if 201103L <= YY_CPLUSPLUS 
 1637        , value (std::move (v))
 
 1638        , location (std::move (l))
 
 1681        value.template destroy< ElementPtr > ();
 
 1685        value.template destroy< bool > ();
 
 1689        value.template destroy< double > ();
 
 1693        value.template destroy< int64_t > ();
 
 1697        value.template destroy< std::string > ();
 
 
 1729#if YY_CPLUSPLUS < 201103L 
 
 1744#if 201103L <= YY_CPLUSPLUS 
 
 1788#if 201103L <= YY_CPLUSPLUS 
 1796#if !defined _MSC_VER || defined __clang__ 
 
 1801#if 201103L <= YY_CPLUSPLUS 
 1809#if !defined _MSC_VER || defined __clang__ 
 
 1813#if 201103L <= YY_CPLUSPLUS 
 1821#if !defined _MSC_VER || defined __clang__ 
 
 1825#if 201103L <= YY_CPLUSPLUS 
 1833#if !defined _MSC_VER || defined __clang__ 
 
 1837#if 201103L <= YY_CPLUSPLUS 
 1845#if !defined _MSC_VER || defined __clang__ 
 
 
 1855#if 201103L <= YY_CPLUSPLUS 
 1868    virtual int parse ();
 
 1874    void set_debug_stream (std::ostream &);
 
 1877    typedef 
int debug_level_type;
 
 1881    void set_debug_level (debug_level_type l);
 
 1887    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1890    void error (
const syntax_error& err);
 
 1894    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1897#if 201103L <= YY_CPLUSPLUS 
 1900      make_END (location_type l)
 
 1902        return symbol_type (token::TOKEN_END, std::move (l));
 
 1912#if 201103L <= YY_CPLUSPLUS 
 1915      make_PARSER6_error (location_type l)
 
 1917        return symbol_type (token::TOKEN_PARSER6_error, std::move (l));
 
 1927#if 201103L <= YY_CPLUSPLUS 
 1930      make_PARSER6_UNDEF (location_type l)
 
 1932        return symbol_type (token::TOKEN_PARSER6_UNDEF, std::move (l));
 
 1942#if 201103L <= YY_CPLUSPLUS 
 1945      make_COMMA (location_type l)
 
 1947        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1957#if 201103L <= YY_CPLUSPLUS 
 1960      make_COLON (location_type l)
 
 1962        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1972#if 201103L <= YY_CPLUSPLUS 
 1975      make_LSQUARE_BRACKET (location_type l)
 
 1977        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 1987#if 201103L <= YY_CPLUSPLUS 
 1990      make_RSQUARE_BRACKET (location_type l)
 
 1992        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 2002#if 201103L <= YY_CPLUSPLUS 
 2005      make_LCURLY_BRACKET (location_type l)
 
 2007        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 2017#if 201103L <= YY_CPLUSPLUS 
 2020      make_RCURLY_BRACKET (location_type l)
 
 2022        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 2032#if 201103L <= YY_CPLUSPLUS 
 2035      make_NULL_TYPE (location_type l)
 
 2037        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 2047#if 201103L <= YY_CPLUSPLUS 
 2050      make_DHCP6 (location_type l)
 
 2052        return symbol_type (token::TOKEN_DHCP6, std::move (l));
 
 2062#if 201103L <= YY_CPLUSPLUS 
 2065      make_DATA_DIRECTORY (location_type l)
 
 2067        return symbol_type (token::TOKEN_DATA_DIRECTORY, std::move (l));
 
 2077#if 201103L <= YY_CPLUSPLUS 
 2080      make_CONFIG_CONTROL (location_type l)
 
 2082        return symbol_type (token::TOKEN_CONFIG_CONTROL, std::move (l));
 
 2092#if 201103L <= YY_CPLUSPLUS 
 2095      make_CONFIG_DATABASES (location_type l)
 
 2097        return symbol_type (token::TOKEN_CONFIG_DATABASES, std::move (l));
 
 2107#if 201103L <= YY_CPLUSPLUS 
 2110      make_CONFIG_FETCH_WAIT_TIME (location_type l)
 
 2112        return symbol_type (token::TOKEN_CONFIG_FETCH_WAIT_TIME, std::move (l));
 
 2122#if 201103L <= YY_CPLUSPLUS 
 2125      make_INTERFACES_CONFIG (location_type l)
 
 2127        return symbol_type (token::TOKEN_INTERFACES_CONFIG, std::move (l));
 
 2137#if 201103L <= YY_CPLUSPLUS 
 2140      make_INTERFACES (location_type l)
 
 2142        return symbol_type (token::TOKEN_INTERFACES, std::move (l));
 
 2152#if 201103L <= YY_CPLUSPLUS 
 2155      make_RE_DETECT (location_type l)
 
 2157        return symbol_type (token::TOKEN_RE_DETECT, std::move (l));
 
 2167#if 201103L <= YY_CPLUSPLUS 
 2170      make_SERVICE_SOCKETS_REQUIRE_ALL (location_type l)
 
 2172        return symbol_type (token::TOKEN_SERVICE_SOCKETS_REQUIRE_ALL, std::move (l));
 
 2182#if 201103L <= YY_CPLUSPLUS 
 2185      make_SERVICE_SOCKETS_RETRY_WAIT_TIME (location_type l)
 
 2187        return symbol_type (token::TOKEN_SERVICE_SOCKETS_RETRY_WAIT_TIME, std::move (l));
 
 2197#if 201103L <= YY_CPLUSPLUS 
 2200      make_SERVICE_SOCKETS_MAX_RETRIES (location_type l)
 
 2202        return symbol_type (token::TOKEN_SERVICE_SOCKETS_MAX_RETRIES, std::move (l));
 
 2212#if 201103L <= YY_CPLUSPLUS 
 2215      make_LEASE_DATABASE (location_type l)
 
 2217        return symbol_type (token::TOKEN_LEASE_DATABASE, std::move (l));
 
 2227#if 201103L <= YY_CPLUSPLUS 
 2230      make_HOSTS_DATABASE (location_type l)
 
 2232        return symbol_type (token::TOKEN_HOSTS_DATABASE, std::move (l));
 
 2242#if 201103L <= YY_CPLUSPLUS 
 2245      make_HOSTS_DATABASES (location_type l)
 
 2247        return symbol_type (token::TOKEN_HOSTS_DATABASES, std::move (l));
 
 2257#if 201103L <= YY_CPLUSPLUS 
 2260      make_TYPE (location_type l)
 
 2262        return symbol_type (token::TOKEN_TYPE, std::move (l));
 
 2272#if 201103L <= YY_CPLUSPLUS 
 2275      make_USER (location_type l)
 
 2277        return symbol_type (token::TOKEN_USER, std::move (l));
 
 2287#if 201103L <= YY_CPLUSPLUS 
 2290      make_PASSWORD (location_type l)
 
 2292        return symbol_type (token::TOKEN_PASSWORD, std::move (l));
 
 2302#if 201103L <= YY_CPLUSPLUS 
 2305      make_HOST (location_type l)
 
 2307        return symbol_type (token::TOKEN_HOST, std::move (l));
 
 2317#if 201103L <= YY_CPLUSPLUS 
 2320      make_PORT (location_type l)
 
 2322        return symbol_type (token::TOKEN_PORT, std::move (l));
 
 2332#if 201103L <= YY_CPLUSPLUS 
 2335      make_PERSIST (location_type l)
 
 2337        return symbol_type (token::TOKEN_PERSIST, std::move (l));
 
 2347#if 201103L <= YY_CPLUSPLUS 
 2350      make_LFC_INTERVAL (location_type l)
 
 2352        return symbol_type (token::TOKEN_LFC_INTERVAL, std::move (l));
 
 2362#if 201103L <= YY_CPLUSPLUS 
 2365      make_READONLY (location_type l)
 
 2367        return symbol_type (token::TOKEN_READONLY, std::move (l));
 
 2377#if 201103L <= YY_CPLUSPLUS 
 2380      make_CONNECT_TIMEOUT (location_type l)
 
 2382        return symbol_type (token::TOKEN_CONNECT_TIMEOUT, std::move (l));
 
 2392#if 201103L <= YY_CPLUSPLUS 
 2395      make_READ_TIMEOUT (location_type l)
 
 2397        return symbol_type (token::TOKEN_READ_TIMEOUT, std::move (l));
 
 2407#if 201103L <= YY_CPLUSPLUS 
 2410      make_WRITE_TIMEOUT (location_type l)
 
 2412        return symbol_type (token::TOKEN_WRITE_TIMEOUT, std::move (l));
 
 2422#if 201103L <= YY_CPLUSPLUS 
 2425      make_TCP_USER_TIMEOUT (location_type l)
 
 2427        return symbol_type (token::TOKEN_TCP_USER_TIMEOUT, std::move (l));
 
 2437#if 201103L <= YY_CPLUSPLUS 
 2440      make_MAX_RECONNECT_TRIES (location_type l)
 
 2442        return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, std::move (l));
 
 2452#if 201103L <= YY_CPLUSPLUS 
 2455      make_RECONNECT_WAIT_TIME (location_type l)
 
 2457        return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, std::move (l));
 
 2467#if 201103L <= YY_CPLUSPLUS 
 2470      make_ON_FAIL (location_type l)
 
 2472        return symbol_type (token::TOKEN_ON_FAIL, std::move (l));
 
 2482#if 201103L <= YY_CPLUSPLUS 
 2485      make_STOP_RETRY_EXIT (location_type l)
 
 2487        return symbol_type (token::TOKEN_STOP_RETRY_EXIT, std::move (l));
 
 2497#if 201103L <= YY_CPLUSPLUS 
 2500      make_SERVE_RETRY_EXIT (location_type l)
 
 2502        return symbol_type (token::TOKEN_SERVE_RETRY_EXIT, std::move (l));
 
 2512#if 201103L <= YY_CPLUSPLUS 
 2515      make_SERVE_RETRY_CONTINUE (location_type l)
 
 2517        return symbol_type (token::TOKEN_SERVE_RETRY_CONTINUE, std::move (l));
 
 2527#if 201103L <= YY_CPLUSPLUS 
 2530      make_RETRY_ON_STARTUP (location_type l)
 
 2532        return symbol_type (token::TOKEN_RETRY_ON_STARTUP, std::move (l));
 
 2542#if 201103L <= YY_CPLUSPLUS 
 2545      make_MAX_ROW_ERRORS (location_type l)
 
 2547        return symbol_type (token::TOKEN_MAX_ROW_ERRORS, std::move (l));
 
 2557#if 201103L <= YY_CPLUSPLUS 
 2560      make_TRUST_ANCHOR (location_type l)
 
 2562        return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
 
 2572#if 201103L <= YY_CPLUSPLUS 
 2575      make_CERT_FILE (location_type l)
 
 2577        return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
 
 2587#if 201103L <= YY_CPLUSPLUS 
 2590      make_KEY_FILE (location_type l)
 
 2592        return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
 
 2602#if 201103L <= YY_CPLUSPLUS 
 2605      make_CIPHER_LIST (location_type l)
 
 2607        return symbol_type (token::TOKEN_CIPHER_LIST, std::move (l));
 
 2617#if 201103L <= YY_CPLUSPLUS 
 2620      make_PREFERRED_LIFETIME (location_type l)
 
 2622        return symbol_type (token::TOKEN_PREFERRED_LIFETIME, std::move (l));
 
 2632#if 201103L <= YY_CPLUSPLUS 
 2635      make_MIN_PREFERRED_LIFETIME (location_type l)
 
 2637        return symbol_type (token::TOKEN_MIN_PREFERRED_LIFETIME, std::move (l));
 
 2647#if 201103L <= YY_CPLUSPLUS 
 2650      make_MAX_PREFERRED_LIFETIME (location_type l)
 
 2652        return symbol_type (token::TOKEN_MAX_PREFERRED_LIFETIME, std::move (l));
 
 2662#if 201103L <= YY_CPLUSPLUS 
 2665      make_VALID_LIFETIME (location_type l)
 
 2667        return symbol_type (token::TOKEN_VALID_LIFETIME, std::move (l));
 
 2677#if 201103L <= YY_CPLUSPLUS 
 2680      make_MIN_VALID_LIFETIME (location_type l)
 
 2682        return symbol_type (token::TOKEN_MIN_VALID_LIFETIME, std::move (l));
 
 2692#if 201103L <= YY_CPLUSPLUS 
 2695      make_MAX_VALID_LIFETIME (location_type l)
 
 2697        return symbol_type (token::TOKEN_MAX_VALID_LIFETIME, std::move (l));
 
 2707#if 201103L <= YY_CPLUSPLUS 
 2710      make_RENEW_TIMER (location_type l)
 
 2712        return symbol_type (token::TOKEN_RENEW_TIMER, std::move (l));
 
 2722#if 201103L <= YY_CPLUSPLUS 
 2725      make_REBIND_TIMER (location_type l)
 
 2727        return symbol_type (token::TOKEN_REBIND_TIMER, std::move (l));
 
 2737#if 201103L <= YY_CPLUSPLUS 
 2740      make_CALCULATE_TEE_TIMES (location_type l)
 
 2742        return symbol_type (token::TOKEN_CALCULATE_TEE_TIMES, std::move (l));
 
 2752#if 201103L <= YY_CPLUSPLUS 
 2755      make_T1_PERCENT (location_type l)
 
 2757        return symbol_type (token::TOKEN_T1_PERCENT, std::move (l));
 
 2767#if 201103L <= YY_CPLUSPLUS 
 2770      make_T2_PERCENT (location_type l)
 
 2772        return symbol_type (token::TOKEN_T2_PERCENT, std::move (l));
 
 2782#if 201103L <= YY_CPLUSPLUS 
 2785      make_CACHE_THRESHOLD (location_type l)
 
 2787        return symbol_type (token::TOKEN_CACHE_THRESHOLD, std::move (l));
 
 2797#if 201103L <= YY_CPLUSPLUS 
 2800      make_CACHE_MAX_AGE (location_type l)
 
 2802        return symbol_type (token::TOKEN_CACHE_MAX_AGE, std::move (l));
 
 2812#if 201103L <= YY_CPLUSPLUS 
 2815      make_DECLINE_PROBATION_PERIOD (location_type l)
 
 2817        return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, std::move (l));
 
 2827#if 201103L <= YY_CPLUSPLUS 
 2830      make_SERVER_TAG (location_type l)
 
 2832        return symbol_type (token::TOKEN_SERVER_TAG, std::move (l));
 
 2842#if 201103L <= YY_CPLUSPLUS 
 2845      make_STATISTIC_DEFAULT_SAMPLE_COUNT (location_type l)
 
 2847        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT, std::move (l));
 
 2857#if 201103L <= YY_CPLUSPLUS 
 2860      make_STATISTIC_DEFAULT_SAMPLE_AGE (location_type l)
 
 2862        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE, std::move (l));
 
 2872#if 201103L <= YY_CPLUSPLUS 
 2875      make_DDNS_SEND_UPDATES (location_type l)
 
 2877        return symbol_type (token::TOKEN_DDNS_SEND_UPDATES, std::move (l));
 
 2887#if 201103L <= YY_CPLUSPLUS 
 2890      make_DDNS_OVERRIDE_NO_UPDATE (location_type l)
 
 2892        return symbol_type (token::TOKEN_DDNS_OVERRIDE_NO_UPDATE, std::move (l));
 
 2902#if 201103L <= YY_CPLUSPLUS 
 2905      make_DDNS_OVERRIDE_CLIENT_UPDATE (location_type l)
 
 2907        return symbol_type (token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE, std::move (l));
 
 2917#if 201103L <= YY_CPLUSPLUS 
 2920      make_DDNS_REPLACE_CLIENT_NAME (location_type l)
 
 2922        return symbol_type (token::TOKEN_DDNS_REPLACE_CLIENT_NAME, std::move (l));
 
 2932#if 201103L <= YY_CPLUSPLUS 
 2935      make_DDNS_GENERATED_PREFIX (location_type l)
 
 2937        return symbol_type (token::TOKEN_DDNS_GENERATED_PREFIX, std::move (l));
 
 2947#if 201103L <= YY_CPLUSPLUS 
 2950      make_DDNS_QUALIFYING_SUFFIX (location_type l)
 
 2952        return symbol_type (token::TOKEN_DDNS_QUALIFYING_SUFFIX, std::move (l));
 
 2962#if 201103L <= YY_CPLUSPLUS 
 2965      make_DDNS_UPDATE_ON_RENEW (location_type l)
 
 2967        return symbol_type (token::TOKEN_DDNS_UPDATE_ON_RENEW, std::move (l));
 
 2977#if 201103L <= YY_CPLUSPLUS 
 2980      make_DDNS_USE_CONFLICT_RESOLUTION (location_type l)
 
 2982        return symbol_type (token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION, std::move (l));
 
 2992#if 201103L <= YY_CPLUSPLUS 
 2995      make_DDNS_TTL_PERCENT (location_type l)
 
 2997        return symbol_type (token::TOKEN_DDNS_TTL_PERCENT, std::move (l));
 
 3007#if 201103L <= YY_CPLUSPLUS 
 3010      make_DDNS_TTL (location_type l)
 
 3012        return symbol_type (token::TOKEN_DDNS_TTL, std::move (l));
 
 3022#if 201103L <= YY_CPLUSPLUS 
 3025      make_DDNS_TTL_MIN (location_type l)
 
 3027        return symbol_type (token::TOKEN_DDNS_TTL_MIN, std::move (l));
 
 3037#if 201103L <= YY_CPLUSPLUS 
 3040      make_DDNS_TTL_MAX (location_type l)
 
 3042        return symbol_type (token::TOKEN_DDNS_TTL_MAX, std::move (l));
 
 3052#if 201103L <= YY_CPLUSPLUS 
 3055      make_STORE_EXTENDED_INFO (location_type l)
 
 3057        return symbol_type (token::TOKEN_STORE_EXTENDED_INFO, std::move (l));
 
 3067#if 201103L <= YY_CPLUSPLUS 
 3070      make_SUBNET6 (location_type l)
 
 3072        return symbol_type (token::TOKEN_SUBNET6, std::move (l));
 
 3082#if 201103L <= YY_CPLUSPLUS 
 3085      make_OPTION_DEF (location_type l)
 
 3087        return symbol_type (token::TOKEN_OPTION_DEF, std::move (l));
 
 3097#if 201103L <= YY_CPLUSPLUS 
 3100      make_OPTION_DATA (location_type l)
 
 3102        return symbol_type (token::TOKEN_OPTION_DATA, std::move (l));
 
 3112#if 201103L <= YY_CPLUSPLUS 
 3115      make_NAME (location_type l)
 
 3117        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 3127#if 201103L <= YY_CPLUSPLUS 
 3130      make_DATA (location_type l)
 
 3132        return symbol_type (token::TOKEN_DATA, std::move (l));
 
 3142#if 201103L <= YY_CPLUSPLUS 
 3145      make_CODE (location_type l)
 
 3147        return symbol_type (token::TOKEN_CODE, std::move (l));
 
 3157#if 201103L <= YY_CPLUSPLUS 
 3160      make_SPACE (location_type l)
 
 3162        return symbol_type (token::TOKEN_SPACE, std::move (l));
 
 3172#if 201103L <= YY_CPLUSPLUS 
 3175      make_CSV_FORMAT (location_type l)
 
 3177        return symbol_type (token::TOKEN_CSV_FORMAT, std::move (l));
 
 3187#if 201103L <= YY_CPLUSPLUS 
 3190      make_ALWAYS_SEND (location_type l)
 
 3192        return symbol_type (token::TOKEN_ALWAYS_SEND, std::move (l));
 
 3202#if 201103L <= YY_CPLUSPLUS 
 3205      make_NEVER_SEND (location_type l)
 
 3207        return symbol_type (token::TOKEN_NEVER_SEND, std::move (l));
 
 3217#if 201103L <= YY_CPLUSPLUS 
 3220      make_RECORD_TYPES (location_type l)
 
 3222        return symbol_type (token::TOKEN_RECORD_TYPES, std::move (l));
 
 3232#if 201103L <= YY_CPLUSPLUS 
 3235      make_ENCAPSULATE (location_type l)
 
 3237        return symbol_type (token::TOKEN_ENCAPSULATE, std::move (l));
 
 3247#if 201103L <= YY_CPLUSPLUS 
 3250      make_ARRAY (location_type l)
 
 3252        return symbol_type (token::TOKEN_ARRAY, std::move (l));
 
 3262#if 201103L <= YY_CPLUSPLUS 
 3265      make_PARKED_PACKET_LIMIT (location_type l)
 
 3267        return symbol_type (token::TOKEN_PARKED_PACKET_LIMIT, std::move (l));
 
 3277#if 201103L <= YY_CPLUSPLUS 
 3280      make_ALLOCATOR (location_type l)
 
 3282        return symbol_type (token::TOKEN_ALLOCATOR, std::move (l));
 
 3292#if 201103L <= YY_CPLUSPLUS 
 3295      make_PD_ALLOCATOR (location_type l)
 
 3297        return symbol_type (token::TOKEN_PD_ALLOCATOR, std::move (l));
 
 3307#if 201103L <= YY_CPLUSPLUS 
 3310      make_DDNS_CONFLICT_RESOLUTION_MODE (location_type l)
 
 3312        return symbol_type (token::TOKEN_DDNS_CONFLICT_RESOLUTION_MODE, std::move (l));
 
 3322#if 201103L <= YY_CPLUSPLUS 
 3325      make_CHECK_WITH_DHCID (location_type l)
 
 3327        return symbol_type (token::TOKEN_CHECK_WITH_DHCID, std::move (l));
 
 3337#if 201103L <= YY_CPLUSPLUS 
 3340      make_NO_CHECK_WITH_DHCID (location_type l)
 
 3342        return symbol_type (token::TOKEN_NO_CHECK_WITH_DHCID, std::move (l));
 
 3352#if 201103L <= YY_CPLUSPLUS 
 3355      make_CHECK_EXISTS_WITH_DHCID (location_type l)
 
 3357        return symbol_type (token::TOKEN_CHECK_EXISTS_WITH_DHCID, std::move (l));
 
 3367#if 201103L <= YY_CPLUSPLUS 
 3370      make_NO_CHECK_WITHOUT_DHCID (location_type l)
 
 3372        return symbol_type (token::TOKEN_NO_CHECK_WITHOUT_DHCID, std::move (l));
 
 3382#if 201103L <= YY_CPLUSPLUS 
 3385      make_SHARED_NETWORKS (location_type l)
 
 3387        return symbol_type (token::TOKEN_SHARED_NETWORKS, std::move (l));
 
 3397#if 201103L <= YY_CPLUSPLUS 
 3400      make_POOLS (location_type l)
 
 3402        return symbol_type (token::TOKEN_POOLS, std::move (l));
 
 3412#if 201103L <= YY_CPLUSPLUS 
 3415      make_POOL (location_type l)
 
 3417        return symbol_type (token::TOKEN_POOL, std::move (l));
 
 3427#if 201103L <= YY_CPLUSPLUS 
 3430      make_PD_POOLS (location_type l)
 
 3432        return symbol_type (token::TOKEN_PD_POOLS, std::move (l));
 
 3442#if 201103L <= YY_CPLUSPLUS 
 3445      make_PREFIX (location_type l)
 
 3447        return symbol_type (token::TOKEN_PREFIX, std::move (l));
 
 3457#if 201103L <= YY_CPLUSPLUS 
 3460      make_PREFIX_LEN (location_type l)
 
 3462        return symbol_type (token::TOKEN_PREFIX_LEN, std::move (l));
 
 3472#if 201103L <= YY_CPLUSPLUS 
 3475      make_EXCLUDED_PREFIX (location_type l)
 
 3477        return symbol_type (token::TOKEN_EXCLUDED_PREFIX, std::move (l));
 
 3487#if 201103L <= YY_CPLUSPLUS 
 3490      make_EXCLUDED_PREFIX_LEN (location_type l)
 
 3492        return symbol_type (token::TOKEN_EXCLUDED_PREFIX_LEN, std::move (l));
 
 3502#if 201103L <= YY_CPLUSPLUS 
 3505      make_DELEGATED_LEN (location_type l)
 
 3507        return symbol_type (token::TOKEN_DELEGATED_LEN, std::move (l));
 
 3517#if 201103L <= YY_CPLUSPLUS 
 3520      make_USER_CONTEXT (location_type l)
 
 3522        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 3532#if 201103L <= YY_CPLUSPLUS 
 3535      make_COMMENT (location_type l)
 
 3537        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 3547#if 201103L <= YY_CPLUSPLUS 
 3550      make_SUBNET (location_type l)
 
 3552        return symbol_type (token::TOKEN_SUBNET, std::move (l));
 
 3562#if 201103L <= YY_CPLUSPLUS 
 3565      make_INTERFACE (location_type l)
 
 3567        return symbol_type (token::TOKEN_INTERFACE, std::move (l));
 
 3577#if 201103L <= YY_CPLUSPLUS 
 3580      make_INTERFACE_ID (location_type l)
 
 3582        return symbol_type (token::TOKEN_INTERFACE_ID, std::move (l));
 
 3592#if 201103L <= YY_CPLUSPLUS 
 3595      make_ID (location_type l)
 
 3597        return symbol_type (token::TOKEN_ID, std::move (l));
 
 3607#if 201103L <= YY_CPLUSPLUS 
 3610      make_RAPID_COMMIT (location_type l)
 
 3612        return symbol_type (token::TOKEN_RAPID_COMMIT, std::move (l));
 
 3622#if 201103L <= YY_CPLUSPLUS 
 3625      make_RESERVATIONS_GLOBAL (location_type l)
 
 3627        return symbol_type (token::TOKEN_RESERVATIONS_GLOBAL, std::move (l));
 
 3637#if 201103L <= YY_CPLUSPLUS 
 3640      make_RESERVATIONS_IN_SUBNET (location_type l)
 
 3642        return symbol_type (token::TOKEN_RESERVATIONS_IN_SUBNET, std::move (l));
 
 3652#if 201103L <= YY_CPLUSPLUS 
 3655      make_RESERVATIONS_OUT_OF_POOL (location_type l)
 
 3657        return symbol_type (token::TOKEN_RESERVATIONS_OUT_OF_POOL, std::move (l));
 
 3667#if 201103L <= YY_CPLUSPLUS 
 3670      make_MAC_SOURCES (location_type l)
 
 3672        return symbol_type (token::TOKEN_MAC_SOURCES, std::move (l));
 
 3682#if 201103L <= YY_CPLUSPLUS 
 3685      make_RELAY_SUPPLIED_OPTIONS (location_type l)
 
 3687        return symbol_type (token::TOKEN_RELAY_SUPPLIED_OPTIONS, std::move (l));
 
 3697#if 201103L <= YY_CPLUSPLUS 
 3700      make_HOST_RESERVATION_IDENTIFIERS (location_type l)
 
 3702        return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, std::move (l));
 
 3712#if 201103L <= YY_CPLUSPLUS 
 3715      make_SANITY_CHECKS (location_type l)
 
 3717        return symbol_type (token::TOKEN_SANITY_CHECKS, std::move (l));
 
 3727#if 201103L <= YY_CPLUSPLUS 
 3730      make_LEASE_CHECKS (location_type l)
 
 3732        return symbol_type (token::TOKEN_LEASE_CHECKS, std::move (l));
 
 3742#if 201103L <= YY_CPLUSPLUS 
 3745      make_EXTENDED_INFO_CHECKS (location_type l)
 
 3747        return symbol_type (token::TOKEN_EXTENDED_INFO_CHECKS, std::move (l));
 
 3757#if 201103L <= YY_CPLUSPLUS 
 3760      make_CLIENT_CLASSES (location_type l)
 
 3762        return symbol_type (token::TOKEN_CLIENT_CLASSES, std::move (l));
 
 3772#if 201103L <= YY_CPLUSPLUS 
 3775      make_REQUIRE_CLIENT_CLASSES (location_type l)
 
 3777        return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, std::move (l));
 
 3787#if 201103L <= YY_CPLUSPLUS 
 3790      make_EVALUATE_ADDITIONAL_CLASSES (location_type l)
 
 3792        return symbol_type (token::TOKEN_EVALUATE_ADDITIONAL_CLASSES, std::move (l));
 
 3802#if 201103L <= YY_CPLUSPLUS 
 3805      make_TEST (location_type l)
 
 3807        return symbol_type (token::TOKEN_TEST, std::move (l));
 
 3817#if 201103L <= YY_CPLUSPLUS 
 3820      make_TEMPLATE_TEST (location_type l)
 
 3822        return symbol_type (token::TOKEN_TEMPLATE_TEST, std::move (l));
 
 3832#if 201103L <= YY_CPLUSPLUS 
 3835      make_ONLY_IF_REQUIRED (location_type l)
 
 3837        return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, std::move (l));
 
 3847#if 201103L <= YY_CPLUSPLUS 
 3850      make_ONLY_IN_ADDITIONAL_LIST (location_type l)
 
 3852        return symbol_type (token::TOKEN_ONLY_IN_ADDITIONAL_LIST, std::move (l));
 
 3862#if 201103L <= YY_CPLUSPLUS 
 3865      make_CLIENT_CLASS (location_type l)
 
 3867        return symbol_type (token::TOKEN_CLIENT_CLASS, std::move (l));
 
 3877#if 201103L <= YY_CPLUSPLUS 
 3880      make_POOL_ID (location_type l)
 
 3882        return symbol_type (token::TOKEN_POOL_ID, std::move (l));
 
 3892#if 201103L <= YY_CPLUSPLUS 
 3895      make_RESERVATIONS (location_type l)
 
 3897        return symbol_type (token::TOKEN_RESERVATIONS, std::move (l));
 
 3907#if 201103L <= YY_CPLUSPLUS 
 3910      make_IP_ADDRESSES (location_type l)
 
 3912        return symbol_type (token::TOKEN_IP_ADDRESSES, std::move (l));
 
 3922#if 201103L <= YY_CPLUSPLUS 
 3925      make_PREFIXES (location_type l)
 
 3927        return symbol_type (token::TOKEN_PREFIXES, std::move (l));
 
 3937#if 201103L <= YY_CPLUSPLUS 
 3940      make_EXCLUDED_PREFIXES (location_type l)
 
 3942        return symbol_type (token::TOKEN_EXCLUDED_PREFIXES, std::move (l));
 
 3952#if 201103L <= YY_CPLUSPLUS 
 3955      make_DUID (location_type l)
 
 3957        return symbol_type (token::TOKEN_DUID, std::move (l));
 
 3967#if 201103L <= YY_CPLUSPLUS 
 3970      make_HW_ADDRESS (location_type l)
 
 3972        return symbol_type (token::TOKEN_HW_ADDRESS, std::move (l));
 
 3982#if 201103L <= YY_CPLUSPLUS 
 3985      make_HOSTNAME (location_type l)
 
 3987        return symbol_type (token::TOKEN_HOSTNAME, std::move (l));
 
 3997#if 201103L <= YY_CPLUSPLUS 
 4000      make_FLEX_ID (location_type l)
 
 4002        return symbol_type (token::TOKEN_FLEX_ID, std::move (l));
 
 4012#if 201103L <= YY_CPLUSPLUS 
 4015      make_RELAY (location_type l)
 
 4017        return symbol_type (token::TOKEN_RELAY, std::move (l));
 
 4027#if 201103L <= YY_CPLUSPLUS 
 4030      make_HOOKS_LIBRARIES (location_type l)
 
 4032        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 4042#if 201103L <= YY_CPLUSPLUS 
 4045      make_LIBRARY (location_type l)
 
 4047        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 4057#if 201103L <= YY_CPLUSPLUS 
 4060      make_PARAMETERS (location_type l)
 
 4062        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 4072#if 201103L <= YY_CPLUSPLUS 
 4075      make_EXPIRED_LEASES_PROCESSING (location_type l)
 
 4077        return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, std::move (l));
 
 4087#if 201103L <= YY_CPLUSPLUS 
 4090      make_RECLAIM_TIMER_WAIT_TIME (location_type l)
 
 4092        return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, std::move (l));
 
 4102#if 201103L <= YY_CPLUSPLUS 
 4105      make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (location_type l)
 
 4107        return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, std::move (l));
 
 4117#if 201103L <= YY_CPLUSPLUS 
 4120      make_HOLD_RECLAIMED_TIME (location_type l)
 
 4122        return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, std::move (l));
 
 4132#if 201103L <= YY_CPLUSPLUS 
 4135      make_MAX_RECLAIM_LEASES (location_type l)
 
 4137        return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, std::move (l));
 
 4147#if 201103L <= YY_CPLUSPLUS 
 4150      make_MAX_RECLAIM_TIME (location_type l)
 
 4152        return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, std::move (l));
 
 4162#if 201103L <= YY_CPLUSPLUS 
 4165      make_UNWARNED_RECLAIM_CYCLES (location_type l)
 
 4167        return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, std::move (l));
 
 4177#if 201103L <= YY_CPLUSPLUS 
 4180      make_SERVER_ID (location_type l)
 
 4182        return symbol_type (token::TOKEN_SERVER_ID, std::move (l));
 
 4192#if 201103L <= YY_CPLUSPLUS 
 4195      make_LLT (location_type l)
 
 4197        return symbol_type (token::TOKEN_LLT, std::move (l));
 
 4207#if 201103L <= YY_CPLUSPLUS 
 4210      make_EN (location_type l)
 
 4212        return symbol_type (token::TOKEN_EN, std::move (l));
 
 4222#if 201103L <= YY_CPLUSPLUS 
 4225      make_LL (location_type l)
 
 4227        return symbol_type (token::TOKEN_LL, std::move (l));
 
 4237#if 201103L <= YY_CPLUSPLUS 
 4240      make_IDENTIFIER (location_type l)
 
 4242        return symbol_type (token::TOKEN_IDENTIFIER, std::move (l));
 
 4252#if 201103L <= YY_CPLUSPLUS 
 4255      make_HTYPE (location_type l)
 
 4257        return symbol_type (token::TOKEN_HTYPE, std::move (l));
 
 4267#if 201103L <= YY_CPLUSPLUS 
 4270      make_TIME (location_type l)
 
 4272        return symbol_type (token::TOKEN_TIME, std::move (l));
 
 4282#if 201103L <= YY_CPLUSPLUS 
 4285      make_ENTERPRISE_ID (location_type l)
 
 4287        return symbol_type (token::TOKEN_ENTERPRISE_ID, std::move (l));
 
 4297#if 201103L <= YY_CPLUSPLUS 
 4300      make_DHCP4O6_PORT (location_type l)
 
 4302        return symbol_type (token::TOKEN_DHCP4O6_PORT, std::move (l));
 
 4312#if 201103L <= YY_CPLUSPLUS 
 4315      make_DHCP_MULTI_THREADING (location_type l)
 
 4317        return symbol_type (token::TOKEN_DHCP_MULTI_THREADING, std::move (l));
 
 4327#if 201103L <= YY_CPLUSPLUS 
 4330      make_ENABLE_MULTI_THREADING (location_type l)
 
 4332        return symbol_type (token::TOKEN_ENABLE_MULTI_THREADING, std::move (l));
 
 4342#if 201103L <= YY_CPLUSPLUS 
 4345      make_THREAD_POOL_SIZE (location_type l)
 
 4347        return symbol_type (token::TOKEN_THREAD_POOL_SIZE, std::move (l));
 
 4357#if 201103L <= YY_CPLUSPLUS 
 4360      make_PACKET_QUEUE_SIZE (location_type l)
 
 4362        return symbol_type (token::TOKEN_PACKET_QUEUE_SIZE, std::move (l));
 
 4372#if 201103L <= YY_CPLUSPLUS 
 4375      make_CONTROL_SOCKET (location_type l)
 
 4377        return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
 
 4387#if 201103L <= YY_CPLUSPLUS 
 4390      make_CONTROL_SOCKETS (location_type l)
 
 4392        return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
 
 4402#if 201103L <= YY_CPLUSPLUS 
 4405      make_SOCKET_TYPE (location_type l)
 
 4407        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 4417#if 201103L <= YY_CPLUSPLUS 
 4420      make_UNIX (location_type l)
 
 4422        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 4432#if 201103L <= YY_CPLUSPLUS 
 4435      make_HTTP (location_type l)
 
 4437        return symbol_type (token::TOKEN_HTTP, std::move (l));
 
 4447#if 201103L <= YY_CPLUSPLUS 
 4450      make_HTTPS (location_type l)
 
 4452        return symbol_type (token::TOKEN_HTTPS, std::move (l));
 
 4462#if 201103L <= YY_CPLUSPLUS 
 4465      make_SOCKET_NAME (location_type l)
 
 4467        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 4477#if 201103L <= YY_CPLUSPLUS 
 4480      make_SOCKET_ADDRESS (location_type l)
 
 4482        return symbol_type (token::TOKEN_SOCKET_ADDRESS, std::move (l));
 
 4492#if 201103L <= YY_CPLUSPLUS 
 4495      make_SOCKET_PORT (location_type l)
 
 4497        return symbol_type (token::TOKEN_SOCKET_PORT, std::move (l));
 
 4507#if 201103L <= YY_CPLUSPLUS 
 4510      make_AUTHENTICATION (location_type l)
 
 4512        return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
 
 4522#if 201103L <= YY_CPLUSPLUS 
 4525      make_BASIC (location_type l)
 
 4527        return symbol_type (token::TOKEN_BASIC, std::move (l));
 
 4537#if 201103L <= YY_CPLUSPLUS 
 4540      make_REALM (location_type l)
 
 4542        return symbol_type (token::TOKEN_REALM, std::move (l));
 
 4552#if 201103L <= YY_CPLUSPLUS 
 4555      make_DIRECTORY (location_type l)
 
 4557        return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
 
 4567#if 201103L <= YY_CPLUSPLUS 
 4570      make_CLIENTS (location_type l)
 
 4572        return symbol_type (token::TOKEN_CLIENTS, std::move (l));
 
 4582#if 201103L <= YY_CPLUSPLUS 
 4585      make_USER_FILE (location_type l)
 
 4587        return symbol_type (token::TOKEN_USER_FILE, std::move (l));
 
 4597#if 201103L <= YY_CPLUSPLUS 
 4600      make_PASSWORD_FILE (location_type l)
 
 4602        return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
 
 4612#if 201103L <= YY_CPLUSPLUS 
 4615      make_CERT_REQUIRED (location_type l)
 
 4617        return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
 
 4627#if 201103L <= YY_CPLUSPLUS 
 4630      make_HTTP_HEADERS (location_type l)
 
 4632        return symbol_type (token::TOKEN_HTTP_HEADERS, std::move (l));
 
 4642#if 201103L <= YY_CPLUSPLUS 
 4645      make_VALUE (location_type l)
 
 4647        return symbol_type (token::TOKEN_VALUE, std::move (l));
 
 4657#if 201103L <= YY_CPLUSPLUS 
 4660      make_DHCP_QUEUE_CONTROL (location_type l)
 
 4662        return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, std::move (l));
 
 4672#if 201103L <= YY_CPLUSPLUS 
 4675      make_ENABLE_QUEUE (location_type l)
 
 4677        return symbol_type (token::TOKEN_ENABLE_QUEUE, std::move (l));
 
 4687#if 201103L <= YY_CPLUSPLUS 
 4690      make_QUEUE_TYPE (location_type l)
 
 4692        return symbol_type (token::TOKEN_QUEUE_TYPE, std::move (l));
 
 4702#if 201103L <= YY_CPLUSPLUS 
 4705      make_CAPACITY (location_type l)
 
 4707        return symbol_type (token::TOKEN_CAPACITY, std::move (l));
 
 4717#if 201103L <= YY_CPLUSPLUS 
 4720      make_DHCP_DDNS (location_type l)
 
 4722        return symbol_type (token::TOKEN_DHCP_DDNS, std::move (l));
 
 4732#if 201103L <= YY_CPLUSPLUS 
 4735      make_ENABLE_UPDATES (location_type l)
 
 4737        return symbol_type (token::TOKEN_ENABLE_UPDATES, std::move (l));
 
 4747#if 201103L <= YY_CPLUSPLUS 
 4750      make_SERVER_IP (location_type l)
 
 4752        return symbol_type (token::TOKEN_SERVER_IP, std::move (l));
 
 4762#if 201103L <= YY_CPLUSPLUS 
 4765      make_SERVER_PORT (location_type l)
 
 4767        return symbol_type (token::TOKEN_SERVER_PORT, std::move (l));
 
 4777#if 201103L <= YY_CPLUSPLUS 
 4780      make_SENDER_IP (location_type l)
 
 4782        return symbol_type (token::TOKEN_SENDER_IP, std::move (l));
 
 4792#if 201103L <= YY_CPLUSPLUS 
 4795      make_SENDER_PORT (location_type l)
 
 4797        return symbol_type (token::TOKEN_SENDER_PORT, std::move (l));
 
 4807#if 201103L <= YY_CPLUSPLUS 
 4810      make_MAX_QUEUE_SIZE (location_type l)
 
 4812        return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, std::move (l));
 
 4822#if 201103L <= YY_CPLUSPLUS 
 4825      make_NCR_PROTOCOL (location_type l)
 
 4827        return symbol_type (token::TOKEN_NCR_PROTOCOL, std::move (l));
 
 4837#if 201103L <= YY_CPLUSPLUS 
 4840      make_NCR_FORMAT (location_type l)
 
 4842        return symbol_type (token::TOKEN_NCR_FORMAT, std::move (l));
 
 4852#if 201103L <= YY_CPLUSPLUS 
 4855      make_UDP (location_type l)
 
 4857        return symbol_type (token::TOKEN_UDP, std::move (l));
 
 4867#if 201103L <= YY_CPLUSPLUS 
 4870      make_TCP (location_type l)
 
 4872        return symbol_type (token::TOKEN_TCP, std::move (l));
 
 4882#if 201103L <= YY_CPLUSPLUS 
 4885      make_JSON (location_type l)
 
 4887        return symbol_type (token::TOKEN_JSON, std::move (l));
 
 4897#if 201103L <= YY_CPLUSPLUS 
 4900      make_WHEN_PRESENT (location_type l)
 
 4902        return symbol_type (token::TOKEN_WHEN_PRESENT, std::move (l));
 
 4912#if 201103L <= YY_CPLUSPLUS 
 4915      make_NEVER (location_type l)
 
 4917        return symbol_type (token::TOKEN_NEVER, std::move (l));
 
 4927#if 201103L <= YY_CPLUSPLUS 
 4930      make_ALWAYS (location_type l)
 
 4932        return symbol_type (token::TOKEN_ALWAYS, std::move (l));
 
 4942#if 201103L <= YY_CPLUSPLUS 
 4945      make_WHEN_NOT_PRESENT (location_type l)
 
 4947        return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, std::move (l));
 
 4957#if 201103L <= YY_CPLUSPLUS 
 4960      make_HOSTNAME_CHAR_SET (location_type l)
 
 4962        return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, std::move (l));
 
 4972#if 201103L <= YY_CPLUSPLUS 
 4975      make_HOSTNAME_CHAR_REPLACEMENT (location_type l)
 
 4977        return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, std::move (l));
 
 4987#if 201103L <= YY_CPLUSPLUS 
 4990      make_EARLY_GLOBAL_RESERVATIONS_LOOKUP (location_type l)
 
 4992        return symbol_type (token::TOKEN_EARLY_GLOBAL_RESERVATIONS_LOOKUP, std::move (l));
 
 5002#if 201103L <= YY_CPLUSPLUS 
 5005      make_IP_RESERVATIONS_UNIQUE (location_type l)
 
 5007        return symbol_type (token::TOKEN_IP_RESERVATIONS_UNIQUE, std::move (l));
 
 5017#if 201103L <= YY_CPLUSPLUS 
 5020      make_RESERVATIONS_LOOKUP_FIRST (location_type l)
 
 5022        return symbol_type (token::TOKEN_RESERVATIONS_LOOKUP_FIRST, std::move (l));
 
 5032#if 201103L <= YY_CPLUSPLUS 
 5035      make_LOGGERS (location_type l)
 
 5037        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 5047#if 201103L <= YY_CPLUSPLUS 
 5050      make_OUTPUT_OPTIONS (location_type l)
 
 5052        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 5062#if 201103L <= YY_CPLUSPLUS 
 5065      make_OUTPUT (location_type l)
 
 5067        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 5077#if 201103L <= YY_CPLUSPLUS 
 5080      make_DEBUGLEVEL (location_type l)
 
 5082        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 5092#if 201103L <= YY_CPLUSPLUS 
 5095      make_SEVERITY (location_type l)
 
 5097        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 5107#if 201103L <= YY_CPLUSPLUS 
 5110      make_FLUSH (location_type l)
 
 5112        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 5122#if 201103L <= YY_CPLUSPLUS 
 5125      make_MAXSIZE (location_type l)
 
 5127        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 5137#if 201103L <= YY_CPLUSPLUS 
 5140      make_MAXVER (location_type l)
 
 5142        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 5152#if 201103L <= YY_CPLUSPLUS 
 5155      make_PATTERN (location_type l)
 
 5157        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 5167#if 201103L <= YY_CPLUSPLUS 
 5170      make_COMPATIBILITY (location_type l)
 
 5172        return symbol_type (token::TOKEN_COMPATIBILITY, std::move (l));
 
 5182#if 201103L <= YY_CPLUSPLUS 
 5185      make_LENIENT_OPTION_PARSING (location_type l)
 
 5187        return symbol_type (token::TOKEN_LENIENT_OPTION_PARSING, std::move (l));
 
 5197#if 201103L <= YY_CPLUSPLUS 
 5200      make_TOPLEVEL_JSON (location_type l)
 
 5202        return symbol_type (token::TOKEN_TOPLEVEL_JSON, std::move (l));
 
 5212#if 201103L <= YY_CPLUSPLUS 
 5215      make_TOPLEVEL_DHCP6 (location_type l)
 
 5217        return symbol_type (token::TOKEN_TOPLEVEL_DHCP6, std::move (l));
 
 5227#if 201103L <= YY_CPLUSPLUS 
 5230      make_SUB_DHCP6 (location_type l)
 
 5232        return symbol_type (token::TOKEN_SUB_DHCP6, std::move (l));
 
 5242#if 201103L <= YY_CPLUSPLUS 
 5245      make_SUB_INTERFACES6 (location_type l)
 
 5247        return symbol_type (token::TOKEN_SUB_INTERFACES6, std::move (l));
 
 5257#if 201103L <= YY_CPLUSPLUS 
 5260      make_SUB_SUBNET6 (location_type l)
 
 5262        return symbol_type (token::TOKEN_SUB_SUBNET6, std::move (l));
 
 5272#if 201103L <= YY_CPLUSPLUS 
 5275      make_SUB_POOL6 (location_type l)
 
 5277        return symbol_type (token::TOKEN_SUB_POOL6, std::move (l));
 
 5287#if 201103L <= YY_CPLUSPLUS 
 5290      make_SUB_PD_POOL (location_type l)
 
 5292        return symbol_type (token::TOKEN_SUB_PD_POOL, std::move (l));
 
 5302#if 201103L <= YY_CPLUSPLUS 
 5305      make_SUB_RESERVATION (location_type l)
 
 5307        return symbol_type (token::TOKEN_SUB_RESERVATION, std::move (l));
 
 5317#if 201103L <= YY_CPLUSPLUS 
 5320      make_SUB_OPTION_DEFS (location_type l)
 
 5322        return symbol_type (token::TOKEN_SUB_OPTION_DEFS, std::move (l));
 
 5332#if 201103L <= YY_CPLUSPLUS 
 5335      make_SUB_OPTION_DEF (location_type l)
 
 5337        return symbol_type (token::TOKEN_SUB_OPTION_DEF, std::move (l));
 
 5347#if 201103L <= YY_CPLUSPLUS 
 5350      make_SUB_OPTION_DATA (location_type l)
 
 5352        return symbol_type (token::TOKEN_SUB_OPTION_DATA, std::move (l));
 
 5362#if 201103L <= YY_CPLUSPLUS 
 5365      make_SUB_HOOKS_LIBRARY (location_type l)
 
 5367        return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, std::move (l));
 
 5377#if 201103L <= YY_CPLUSPLUS 
 5380      make_SUB_DHCP_DDNS (location_type l)
 
 5382        return symbol_type (token::TOKEN_SUB_DHCP_DDNS, std::move (l));
 
 5392#if 201103L <= YY_CPLUSPLUS 
 5395      make_SUB_CONFIG_CONTROL (location_type l)
 
 5397        return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, std::move (l));
 
 5407#if 201103L <= YY_CPLUSPLUS 
 5410      make_STRING (std::string v, location_type l)
 
 5412        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 5422#if 201103L <= YY_CPLUSPLUS 
 5425      make_INTEGER (int64_t v, location_type l)
 
 5427        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 5437#if 201103L <= YY_CPLUSPLUS 
 5440      make_FLOAT (
double v, location_type l)
 
 5442        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 5452#if 201103L <= YY_CPLUSPLUS 
 5455      make_BOOLEAN (
bool v, location_type l)
 
 5457        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 5488#if YY_CPLUSPLUS < 201103L 
 5497    typedef short state_type;
 
 5500    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 5501                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 5505    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 5509    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 5513    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5517    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5519    static const short yypact_ninf_;
 
 5520    static const signed char yytable_ninf_;
 
 5525    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 5528    static std::string yytnamerr_ (
const char *yystr);
 
 5531    static const char* 
const yytname_[];
 
 5537    static const short yypact_[];
 
 5542    static const short yydefact_[];
 
 5545    static const short yypgoto_[];
 
 5548    static const short yydefgoto_[];
 
 5553    static const short yytable_[];
 
 5555    static const short yycheck_[];
 
 5559    static const short yystos_[];
 
 5562    static const short yyr1_[];
 
 5565    static const signed char yyr2_[];
 
 5570    static const short yyrline_[];
 
 5572    virtual void yy_reduce_print_ (
int r) 
const;
 
 5574    virtual void yy_stack_print_ () 
const;
 
 5579    std::ostream* yycdebug_;
 
 5584    template <
typename Base>
 
 5585    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 5592    template <
typename Base>
 
 5593    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 5603      typedef state_type kind_type;
 
 5615      void move (by_state& that);
 
 5623      enum { empty_state = 0 };
 
 5631    struct stack_symbol_type : basic_symbol<by_state>
 
 5634      typedef basic_symbol<by_state> super_type;
 
 5636      stack_symbol_type ();
 
 5638      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 5640      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 5641#if YY_CPLUSPLUS < 201103L 
 5644      stack_symbol_type& operator= (stack_symbol_type& that);
 
 5648      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 5653    template <
typename T, 
typename S = std::vector<T> >
 
 5658      typedef typename S::iterator iterator;
 
 5659      typedef typename S::const_iterator const_iterator;
 
 5660      typedef typename S::size_type size_type;
 
 5661      typedef typename std::ptrdiff_t index_type;
 
 5667#if 201103L <= YY_CPLUSPLUS 
 5669      stack (
const stack&) = 
delete;
 
 5671      stack& operator= (
const stack&) = 
delete;
 
 5678      operator[] (index_type i)
 const 
 5680        return seq_[size_type (size () - 1 - i)];
 
 5687      operator[] (index_type i)
 
 5689        return seq_[size_type (size () - 1 - i)];
 
 5698        seq_.push_back (T ());
 
 5699        operator[] (0).move (t);
 
 5721        return index_type (seq_.size ());
 
 5728        return seq_.begin ();
 
 5748        operator[] (index_type i)
 const 
 5750          return stack_[range_ - i];
 
 
 5754        const stack& stack_;
 
 
 5759#if YY_CPLUSPLUS < 201103L 
 5761      stack (
const stack&);
 
 5763      stack& operator= (
const stack&);
 
 5771    typedef stack<stack_symbol_type> stack_type;
 
 5774    stack_type yystack_;
 
 5781    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 5789    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);