220#  pragma GCC message "bison: do not #define PARSER4_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 ())
 
 
 
 1482    template <
typename Base>
 
 1494#if 201103L <= YY_CPLUSPLUS 
 1497        : Base (std::move (that))
 
 1499        , location (std::move (that.location))
 
 1501        switch (this->kind ())
 
 1513        value.move< 
ElementPtr > (std::move (that.value));
 
 1517        value.move< 
bool > (std::move (that.value));
 
 1521        value.move< 
double > (std::move (that.value));
 
 1525        value.move< int64_t > (std::move (that.value));
 
 1529        value.move< std::string > (std::move (that.value));
 
 1543#if 201103L <= YY_CPLUSPLUS 
 1555#if 201103L <= YY_CPLUSPLUS 
 1558        , value (std::move (v))
 
 1559        , location (std::move (l))
 
 1569#if 201103L <= YY_CPLUSPLUS 
 1572        , value (std::move (v))
 
 1573        , location (std::move (l))
 
 1583#if 201103L <= YY_CPLUSPLUS 
 1586        , value (std::move (v))
 
 1587        , location (std::move (l))
 
 1597#if 201103L <= YY_CPLUSPLUS 
 1600        , value (std::move (v))
 
 1601        , location (std::move (l))
 
 1611#if 201103L <= YY_CPLUSPLUS 
 1614        , value (std::move (v))
 
 1615        , location (std::move (l))
 
 1659        value.template destroy< ElementPtr > ();
 
 1663        value.template destroy< bool > ();
 
 1667        value.template destroy< double > ();
 
 1671        value.template destroy< int64_t > ();
 
 1675        value.template destroy< std::string > ();
 
 
 1707#if YY_CPLUSPLUS < 201103L 
 
 1722#if 201103L <= YY_CPLUSPLUS 
 
 1766#if 201103L <= YY_CPLUSPLUS 
 1774#if !defined _MSC_VER || defined __clang__ 
 
 1779#if 201103L <= YY_CPLUSPLUS 
 1787#if !defined _MSC_VER || defined __clang__ 
 
 1791#if 201103L <= YY_CPLUSPLUS 
 1799#if !defined _MSC_VER || defined __clang__ 
 
 1803#if 201103L <= YY_CPLUSPLUS 
 1811#if !defined _MSC_VER || defined __clang__ 
 
 1815#if 201103L <= YY_CPLUSPLUS 
 1823#if !defined _MSC_VER || defined __clang__ 
 
 
 1833#if 201103L <= YY_CPLUSPLUS 
 1846    virtual int parse ();
 
 1852    void set_debug_stream (std::ostream &);
 
 1855    typedef 
int debug_level_type;
 
 1859    void set_debug_level (debug_level_type l);
 
 1865    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1868    void error (
const syntax_error& err);
 
 1872    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1875#if 201103L <= YY_CPLUSPLUS 
 1878      make_END (location_type l)
 
 1880        return symbol_type (token::TOKEN_END, std::move (l));
 
 1890#if 201103L <= YY_CPLUSPLUS 
 1893      make_PARSER4_error (location_type l)
 
 1895        return symbol_type (token::TOKEN_PARSER4_error, std::move (l));
 
 1905#if 201103L <= YY_CPLUSPLUS 
 1908      make_PARSER4_UNDEF (location_type l)
 
 1910        return symbol_type (token::TOKEN_PARSER4_UNDEF, std::move (l));
 
 1920#if 201103L <= YY_CPLUSPLUS 
 1923      make_COMMA (location_type l)
 
 1925        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1935#if 201103L <= YY_CPLUSPLUS 
 1938      make_COLON (location_type l)
 
 1940        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1950#if 201103L <= YY_CPLUSPLUS 
 1953      make_LSQUARE_BRACKET (location_type l)
 
 1955        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 1965#if 201103L <= YY_CPLUSPLUS 
 1968      make_RSQUARE_BRACKET (location_type l)
 
 1970        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 1980#if 201103L <= YY_CPLUSPLUS 
 1983      make_LCURLY_BRACKET (location_type l)
 
 1985        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 1995#if 201103L <= YY_CPLUSPLUS 
 1998      make_RCURLY_BRACKET (location_type l)
 
 2000        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 2010#if 201103L <= YY_CPLUSPLUS 
 2013      make_NULL_TYPE (location_type l)
 
 2015        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 2025#if 201103L <= YY_CPLUSPLUS 
 2028      make_DHCP4 (location_type l)
 
 2030        return symbol_type (token::TOKEN_DHCP4, std::move (l));
 
 2040#if 201103L <= YY_CPLUSPLUS 
 2043      make_CONFIG_CONTROL (location_type l)
 
 2045        return symbol_type (token::TOKEN_CONFIG_CONTROL, std::move (l));
 
 2055#if 201103L <= YY_CPLUSPLUS 
 2058      make_CONFIG_DATABASES (location_type l)
 
 2060        return symbol_type (token::TOKEN_CONFIG_DATABASES, std::move (l));
 
 2070#if 201103L <= YY_CPLUSPLUS 
 2073      make_CONFIG_FETCH_WAIT_TIME (location_type l)
 
 2075        return symbol_type (token::TOKEN_CONFIG_FETCH_WAIT_TIME, std::move (l));
 
 2085#if 201103L <= YY_CPLUSPLUS 
 2088      make_INTERFACES_CONFIG (location_type l)
 
 2090        return symbol_type (token::TOKEN_INTERFACES_CONFIG, std::move (l));
 
 2100#if 201103L <= YY_CPLUSPLUS 
 2103      make_INTERFACES (location_type l)
 
 2105        return symbol_type (token::TOKEN_INTERFACES, std::move (l));
 
 2115#if 201103L <= YY_CPLUSPLUS 
 2118      make_DHCP_SOCKET_TYPE (location_type l)
 
 2120        return symbol_type (token::TOKEN_DHCP_SOCKET_TYPE, std::move (l));
 
 2130#if 201103L <= YY_CPLUSPLUS 
 2133      make_RAW (location_type l)
 
 2135        return symbol_type (token::TOKEN_RAW, std::move (l));
 
 2145#if 201103L <= YY_CPLUSPLUS 
 2148      make_UDP (location_type l)
 
 2150        return symbol_type (token::TOKEN_UDP, std::move (l));
 
 2160#if 201103L <= YY_CPLUSPLUS 
 2163      make_OUTBOUND_INTERFACE (location_type l)
 
 2165        return symbol_type (token::TOKEN_OUTBOUND_INTERFACE, std::move (l));
 
 2175#if 201103L <= YY_CPLUSPLUS 
 2178      make_SAME_AS_INBOUND (location_type l)
 
 2180        return symbol_type (token::TOKEN_SAME_AS_INBOUND, std::move (l));
 
 2190#if 201103L <= YY_CPLUSPLUS 
 2193      make_USE_ROUTING (location_type l)
 
 2195        return symbol_type (token::TOKEN_USE_ROUTING, std::move (l));
 
 2205#if 201103L <= YY_CPLUSPLUS 
 2208      make_RE_DETECT (location_type l)
 
 2210        return symbol_type (token::TOKEN_RE_DETECT, std::move (l));
 
 2220#if 201103L <= YY_CPLUSPLUS 
 2223      make_SERVICE_SOCKETS_REQUIRE_ALL (location_type l)
 
 2225        return symbol_type (token::TOKEN_SERVICE_SOCKETS_REQUIRE_ALL, std::move (l));
 
 2235#if 201103L <= YY_CPLUSPLUS 
 2238      make_SERVICE_SOCKETS_RETRY_WAIT_TIME (location_type l)
 
 2240        return symbol_type (token::TOKEN_SERVICE_SOCKETS_RETRY_WAIT_TIME, std::move (l));
 
 2250#if 201103L <= YY_CPLUSPLUS 
 2253      make_SERVICE_SOCKETS_MAX_RETRIES (location_type l)
 
 2255        return symbol_type (token::TOKEN_SERVICE_SOCKETS_MAX_RETRIES, std::move (l));
 
 2265#if 201103L <= YY_CPLUSPLUS 
 2268      make_SANITY_CHECKS (location_type l)
 
 2270        return symbol_type (token::TOKEN_SANITY_CHECKS, std::move (l));
 
 2280#if 201103L <= YY_CPLUSPLUS 
 2283      make_LEASE_CHECKS (location_type l)
 
 2285        return symbol_type (token::TOKEN_LEASE_CHECKS, std::move (l));
 
 2295#if 201103L <= YY_CPLUSPLUS 
 2298      make_EXTENDED_INFO_CHECKS (location_type l)
 
 2300        return symbol_type (token::TOKEN_EXTENDED_INFO_CHECKS, std::move (l));
 
 2310#if 201103L <= YY_CPLUSPLUS 
 2313      make_ECHO_CLIENT_ID (location_type l)
 
 2315        return symbol_type (token::TOKEN_ECHO_CLIENT_ID, std::move (l));
 
 2325#if 201103L <= YY_CPLUSPLUS 
 2328      make_MATCH_CLIENT_ID (location_type l)
 
 2330        return symbol_type (token::TOKEN_MATCH_CLIENT_ID, std::move (l));
 
 2340#if 201103L <= YY_CPLUSPLUS 
 2343      make_AUTHORITATIVE (location_type l)
 
 2345        return symbol_type (token::TOKEN_AUTHORITATIVE, std::move (l));
 
 2355#if 201103L <= YY_CPLUSPLUS 
 2358      make_NEXT_SERVER (location_type l)
 
 2360        return symbol_type (token::TOKEN_NEXT_SERVER, std::move (l));
 
 2370#if 201103L <= YY_CPLUSPLUS 
 2373      make_SERVER_HOSTNAME (location_type l)
 
 2375        return symbol_type (token::TOKEN_SERVER_HOSTNAME, std::move (l));
 
 2385#if 201103L <= YY_CPLUSPLUS 
 2388      make_BOOT_FILE_NAME (location_type l)
 
 2390        return symbol_type (token::TOKEN_BOOT_FILE_NAME, std::move (l));
 
 2400#if 201103L <= YY_CPLUSPLUS 
 2403      make_OFFER_LFT (location_type l)
 
 2405        return symbol_type (token::TOKEN_OFFER_LFT, std::move (l));
 
 2415#if 201103L <= YY_CPLUSPLUS 
 2418      make_STASH_AGENT_OPTIONS (location_type l)
 
 2420        return symbol_type (token::TOKEN_STASH_AGENT_OPTIONS, std::move (l));
 
 2430#if 201103L <= YY_CPLUSPLUS 
 2433      make_LEASE_DATABASE (location_type l)
 
 2435        return symbol_type (token::TOKEN_LEASE_DATABASE, std::move (l));
 
 2445#if 201103L <= YY_CPLUSPLUS 
 2448      make_HOSTS_DATABASE (location_type l)
 
 2450        return symbol_type (token::TOKEN_HOSTS_DATABASE, std::move (l));
 
 2460#if 201103L <= YY_CPLUSPLUS 
 2463      make_HOSTS_DATABASES (location_type l)
 
 2465        return symbol_type (token::TOKEN_HOSTS_DATABASES, std::move (l));
 
 2475#if 201103L <= YY_CPLUSPLUS 
 2478      make_TYPE (location_type l)
 
 2480        return symbol_type (token::TOKEN_TYPE, std::move (l));
 
 2490#if 201103L <= YY_CPLUSPLUS 
 2493      make_USER (location_type l)
 
 2495        return symbol_type (token::TOKEN_USER, std::move (l));
 
 2505#if 201103L <= YY_CPLUSPLUS 
 2508      make_PASSWORD (location_type l)
 
 2510        return symbol_type (token::TOKEN_PASSWORD, std::move (l));
 
 2520#if 201103L <= YY_CPLUSPLUS 
 2523      make_HOST (location_type l)
 
 2525        return symbol_type (token::TOKEN_HOST, std::move (l));
 
 2535#if 201103L <= YY_CPLUSPLUS 
 2538      make_PORT (location_type l)
 
 2540        return symbol_type (token::TOKEN_PORT, std::move (l));
 
 2550#if 201103L <= YY_CPLUSPLUS 
 2553      make_PERSIST (location_type l)
 
 2555        return symbol_type (token::TOKEN_PERSIST, std::move (l));
 
 2565#if 201103L <= YY_CPLUSPLUS 
 2568      make_LFC_INTERVAL (location_type l)
 
 2570        return symbol_type (token::TOKEN_LFC_INTERVAL, std::move (l));
 
 2580#if 201103L <= YY_CPLUSPLUS 
 2583      make_READONLY (location_type l)
 
 2585        return symbol_type (token::TOKEN_READONLY, std::move (l));
 
 2595#if 201103L <= YY_CPLUSPLUS 
 2598      make_CONNECT_TIMEOUT (location_type l)
 
 2600        return symbol_type (token::TOKEN_CONNECT_TIMEOUT, std::move (l));
 
 2610#if 201103L <= YY_CPLUSPLUS 
 2613      make_READ_TIMEOUT (location_type l)
 
 2615        return symbol_type (token::TOKEN_READ_TIMEOUT, std::move (l));
 
 2625#if 201103L <= YY_CPLUSPLUS 
 2628      make_WRITE_TIMEOUT (location_type l)
 
 2630        return symbol_type (token::TOKEN_WRITE_TIMEOUT, std::move (l));
 
 2640#if 201103L <= YY_CPLUSPLUS 
 2643      make_TCP_USER_TIMEOUT (location_type l)
 
 2645        return symbol_type (token::TOKEN_TCP_USER_TIMEOUT, std::move (l));
 
 2655#if 201103L <= YY_CPLUSPLUS 
 2658      make_MAX_RECONNECT_TRIES (location_type l)
 
 2660        return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, std::move (l));
 
 2670#if 201103L <= YY_CPLUSPLUS 
 2673      make_RECONNECT_WAIT_TIME (location_type l)
 
 2675        return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, std::move (l));
 
 2685#if 201103L <= YY_CPLUSPLUS 
 2688      make_ON_FAIL (location_type l)
 
 2690        return symbol_type (token::TOKEN_ON_FAIL, std::move (l));
 
 2700#if 201103L <= YY_CPLUSPLUS 
 2703      make_STOP_RETRY_EXIT (location_type l)
 
 2705        return symbol_type (token::TOKEN_STOP_RETRY_EXIT, std::move (l));
 
 2715#if 201103L <= YY_CPLUSPLUS 
 2718      make_SERVE_RETRY_EXIT (location_type l)
 
 2720        return symbol_type (token::TOKEN_SERVE_RETRY_EXIT, std::move (l));
 
 2730#if 201103L <= YY_CPLUSPLUS 
 2733      make_SERVE_RETRY_CONTINUE (location_type l)
 
 2735        return symbol_type (token::TOKEN_SERVE_RETRY_CONTINUE, std::move (l));
 
 2745#if 201103L <= YY_CPLUSPLUS 
 2748      make_RETRY_ON_STARTUP (location_type l)
 
 2750        return symbol_type (token::TOKEN_RETRY_ON_STARTUP, std::move (l));
 
 2760#if 201103L <= YY_CPLUSPLUS 
 2763      make_MAX_ROW_ERRORS (location_type l)
 
 2765        return symbol_type (token::TOKEN_MAX_ROW_ERRORS, std::move (l));
 
 2775#if 201103L <= YY_CPLUSPLUS 
 2778      make_TRUST_ANCHOR (location_type l)
 
 2780        return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
 
 2790#if 201103L <= YY_CPLUSPLUS 
 2793      make_CERT_FILE (location_type l)
 
 2795        return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
 
 2805#if 201103L <= YY_CPLUSPLUS 
 2808      make_KEY_FILE (location_type l)
 
 2810        return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
 
 2820#if 201103L <= YY_CPLUSPLUS 
 2823      make_CIPHER_LIST (location_type l)
 
 2825        return symbol_type (token::TOKEN_CIPHER_LIST, std::move (l));
 
 2835#if 201103L <= YY_CPLUSPLUS 
 2838      make_VALID_LIFETIME (location_type l)
 
 2840        return symbol_type (token::TOKEN_VALID_LIFETIME, std::move (l));
 
 2850#if 201103L <= YY_CPLUSPLUS 
 2853      make_MIN_VALID_LIFETIME (location_type l)
 
 2855        return symbol_type (token::TOKEN_MIN_VALID_LIFETIME, std::move (l));
 
 2865#if 201103L <= YY_CPLUSPLUS 
 2868      make_MAX_VALID_LIFETIME (location_type l)
 
 2870        return symbol_type (token::TOKEN_MAX_VALID_LIFETIME, std::move (l));
 
 2880#if 201103L <= YY_CPLUSPLUS 
 2883      make_RENEW_TIMER (location_type l)
 
 2885        return symbol_type (token::TOKEN_RENEW_TIMER, std::move (l));
 
 2895#if 201103L <= YY_CPLUSPLUS 
 2898      make_REBIND_TIMER (location_type l)
 
 2900        return symbol_type (token::TOKEN_REBIND_TIMER, std::move (l));
 
 2910#if 201103L <= YY_CPLUSPLUS 
 2913      make_CALCULATE_TEE_TIMES (location_type l)
 
 2915        return symbol_type (token::TOKEN_CALCULATE_TEE_TIMES, std::move (l));
 
 2925#if 201103L <= YY_CPLUSPLUS 
 2928      make_T1_PERCENT (location_type l)
 
 2930        return symbol_type (token::TOKEN_T1_PERCENT, std::move (l));
 
 2940#if 201103L <= YY_CPLUSPLUS 
 2943      make_T2_PERCENT (location_type l)
 
 2945        return symbol_type (token::TOKEN_T2_PERCENT, std::move (l));
 
 2955#if 201103L <= YY_CPLUSPLUS 
 2958      make_CACHE_THRESHOLD (location_type l)
 
 2960        return symbol_type (token::TOKEN_CACHE_THRESHOLD, std::move (l));
 
 2970#if 201103L <= YY_CPLUSPLUS 
 2973      make_CACHE_MAX_AGE (location_type l)
 
 2975        return symbol_type (token::TOKEN_CACHE_MAX_AGE, std::move (l));
 
 2985#if 201103L <= YY_CPLUSPLUS 
 2988      make_DECLINE_PROBATION_PERIOD (location_type l)
 
 2990        return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, std::move (l));
 
 3000#if 201103L <= YY_CPLUSPLUS 
 3003      make_SERVER_TAG (location_type l)
 
 3005        return symbol_type (token::TOKEN_SERVER_TAG, std::move (l));
 
 3015#if 201103L <= YY_CPLUSPLUS 
 3018      make_STATISTIC_DEFAULT_SAMPLE_COUNT (location_type l)
 
 3020        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT, std::move (l));
 
 3030#if 201103L <= YY_CPLUSPLUS 
 3033      make_STATISTIC_DEFAULT_SAMPLE_AGE (location_type l)
 
 3035        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE, std::move (l));
 
 3045#if 201103L <= YY_CPLUSPLUS 
 3048      make_DDNS_SEND_UPDATES (location_type l)
 
 3050        return symbol_type (token::TOKEN_DDNS_SEND_UPDATES, std::move (l));
 
 3060#if 201103L <= YY_CPLUSPLUS 
 3063      make_DDNS_OVERRIDE_NO_UPDATE (location_type l)
 
 3065        return symbol_type (token::TOKEN_DDNS_OVERRIDE_NO_UPDATE, std::move (l));
 
 3075#if 201103L <= YY_CPLUSPLUS 
 3078      make_DDNS_OVERRIDE_CLIENT_UPDATE (location_type l)
 
 3080        return symbol_type (token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE, std::move (l));
 
 3090#if 201103L <= YY_CPLUSPLUS 
 3093      make_DDNS_REPLACE_CLIENT_NAME (location_type l)
 
 3095        return symbol_type (token::TOKEN_DDNS_REPLACE_CLIENT_NAME, std::move (l));
 
 3105#if 201103L <= YY_CPLUSPLUS 
 3108      make_DDNS_GENERATED_PREFIX (location_type l)
 
 3110        return symbol_type (token::TOKEN_DDNS_GENERATED_PREFIX, std::move (l));
 
 3120#if 201103L <= YY_CPLUSPLUS 
 3123      make_DDNS_QUALIFYING_SUFFIX (location_type l)
 
 3125        return symbol_type (token::TOKEN_DDNS_QUALIFYING_SUFFIX, std::move (l));
 
 3135#if 201103L <= YY_CPLUSPLUS 
 3138      make_DDNS_UPDATE_ON_RENEW (location_type l)
 
 3140        return symbol_type (token::TOKEN_DDNS_UPDATE_ON_RENEW, std::move (l));
 
 3150#if 201103L <= YY_CPLUSPLUS 
 3153      make_DDNS_USE_CONFLICT_RESOLUTION (location_type l)
 
 3155        return symbol_type (token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION, std::move (l));
 
 3165#if 201103L <= YY_CPLUSPLUS 
 3168      make_DDNS_TTL_PERCENT (location_type l)
 
 3170        return symbol_type (token::TOKEN_DDNS_TTL_PERCENT, std::move (l));
 
 3180#if 201103L <= YY_CPLUSPLUS 
 3183      make_DDNS_TTL (location_type l)
 
 3185        return symbol_type (token::TOKEN_DDNS_TTL, std::move (l));
 
 3195#if 201103L <= YY_CPLUSPLUS 
 3198      make_DDNS_TTL_MIN (location_type l)
 
 3200        return symbol_type (token::TOKEN_DDNS_TTL_MIN, std::move (l));
 
 3210#if 201103L <= YY_CPLUSPLUS 
 3213      make_DDNS_TTL_MAX (location_type l)
 
 3215        return symbol_type (token::TOKEN_DDNS_TTL_MAX, std::move (l));
 
 3225#if 201103L <= YY_CPLUSPLUS 
 3228      make_STORE_EXTENDED_INFO (location_type l)
 
 3230        return symbol_type (token::TOKEN_STORE_EXTENDED_INFO, std::move (l));
 
 3240#if 201103L <= YY_CPLUSPLUS 
 3243      make_SUBNET4 (location_type l)
 
 3245        return symbol_type (token::TOKEN_SUBNET4, std::move (l));
 
 3255#if 201103L <= YY_CPLUSPLUS 
 3258      make_SUBNET_4O6_INTERFACE (location_type l)
 
 3260        return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE, std::move (l));
 
 3270#if 201103L <= YY_CPLUSPLUS 
 3273      make_SUBNET_4O6_INTERFACE_ID (location_type l)
 
 3275        return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE_ID, std::move (l));
 
 3285#if 201103L <= YY_CPLUSPLUS 
 3288      make_SUBNET_4O6_SUBNET (location_type l)
 
 3290        return symbol_type (token::TOKEN_SUBNET_4O6_SUBNET, std::move (l));
 
 3300#if 201103L <= YY_CPLUSPLUS 
 3303      make_OPTION_DEF (location_type l)
 
 3305        return symbol_type (token::TOKEN_OPTION_DEF, std::move (l));
 
 3315#if 201103L <= YY_CPLUSPLUS 
 3318      make_OPTION_DATA (location_type l)
 
 3320        return symbol_type (token::TOKEN_OPTION_DATA, std::move (l));
 
 3330#if 201103L <= YY_CPLUSPLUS 
 3333      make_NAME (location_type l)
 
 3335        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 3345#if 201103L <= YY_CPLUSPLUS 
 3348      make_DATA (location_type l)
 
 3350        return symbol_type (token::TOKEN_DATA, std::move (l));
 
 3360#if 201103L <= YY_CPLUSPLUS 
 3363      make_CODE (location_type l)
 
 3365        return symbol_type (token::TOKEN_CODE, std::move (l));
 
 3375#if 201103L <= YY_CPLUSPLUS 
 3378      make_SPACE (location_type l)
 
 3380        return symbol_type (token::TOKEN_SPACE, std::move (l));
 
 3390#if 201103L <= YY_CPLUSPLUS 
 3393      make_CSV_FORMAT (location_type l)
 
 3395        return symbol_type (token::TOKEN_CSV_FORMAT, std::move (l));
 
 3405#if 201103L <= YY_CPLUSPLUS 
 3408      make_ALWAYS_SEND (location_type l)
 
 3410        return symbol_type (token::TOKEN_ALWAYS_SEND, std::move (l));
 
 3420#if 201103L <= YY_CPLUSPLUS 
 3423      make_NEVER_SEND (location_type l)
 
 3425        return symbol_type (token::TOKEN_NEVER_SEND, std::move (l));
 
 3435#if 201103L <= YY_CPLUSPLUS 
 3438      make_RECORD_TYPES (location_type l)
 
 3440        return symbol_type (token::TOKEN_RECORD_TYPES, std::move (l));
 
 3450#if 201103L <= YY_CPLUSPLUS 
 3453      make_ENCAPSULATE (location_type l)
 
 3455        return symbol_type (token::TOKEN_ENCAPSULATE, std::move (l));
 
 3465#if 201103L <= YY_CPLUSPLUS 
 3468      make_ARRAY (location_type l)
 
 3470        return symbol_type (token::TOKEN_ARRAY, std::move (l));
 
 3480#if 201103L <= YY_CPLUSPLUS 
 3483      make_PARKED_PACKET_LIMIT (location_type l)
 
 3485        return symbol_type (token::TOKEN_PARKED_PACKET_LIMIT, std::move (l));
 
 3495#if 201103L <= YY_CPLUSPLUS 
 3498      make_ALLOCATOR (location_type l)
 
 3500        return symbol_type (token::TOKEN_ALLOCATOR, std::move (l));
 
 3510#if 201103L <= YY_CPLUSPLUS 
 3513      make_DDNS_CONFLICT_RESOLUTION_MODE (location_type l)
 
 3515        return symbol_type (token::TOKEN_DDNS_CONFLICT_RESOLUTION_MODE, std::move (l));
 
 3525#if 201103L <= YY_CPLUSPLUS 
 3528      make_CHECK_WITH_DHCID (location_type l)
 
 3530        return symbol_type (token::TOKEN_CHECK_WITH_DHCID, std::move (l));
 
 3540#if 201103L <= YY_CPLUSPLUS 
 3543      make_NO_CHECK_WITH_DHCID (location_type l)
 
 3545        return symbol_type (token::TOKEN_NO_CHECK_WITH_DHCID, std::move (l));
 
 3555#if 201103L <= YY_CPLUSPLUS 
 3558      make_CHECK_EXISTS_WITH_DHCID (location_type l)
 
 3560        return symbol_type (token::TOKEN_CHECK_EXISTS_WITH_DHCID, std::move (l));
 
 3570#if 201103L <= YY_CPLUSPLUS 
 3573      make_NO_CHECK_WITHOUT_DHCID (location_type l)
 
 3575        return symbol_type (token::TOKEN_NO_CHECK_WITHOUT_DHCID, std::move (l));
 
 3585#if 201103L <= YY_CPLUSPLUS 
 3588      make_SHARED_NETWORKS (location_type l)
 
 3590        return symbol_type (token::TOKEN_SHARED_NETWORKS, std::move (l));
 
 3600#if 201103L <= YY_CPLUSPLUS 
 3603      make_POOLS (location_type l)
 
 3605        return symbol_type (token::TOKEN_POOLS, std::move (l));
 
 3615#if 201103L <= YY_CPLUSPLUS 
 3618      make_POOL (location_type l)
 
 3620        return symbol_type (token::TOKEN_POOL, std::move (l));
 
 3630#if 201103L <= YY_CPLUSPLUS 
 3633      make_USER_CONTEXT (location_type l)
 
 3635        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 3645#if 201103L <= YY_CPLUSPLUS 
 3648      make_COMMENT (location_type l)
 
 3650        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 3660#if 201103L <= YY_CPLUSPLUS 
 3663      make_SUBNET (location_type l)
 
 3665        return symbol_type (token::TOKEN_SUBNET, std::move (l));
 
 3675#if 201103L <= YY_CPLUSPLUS 
 3678      make_INTERFACE (location_type l)
 
 3680        return symbol_type (token::TOKEN_INTERFACE, std::move (l));
 
 3690#if 201103L <= YY_CPLUSPLUS 
 3693      make_ID (location_type l)
 
 3695        return symbol_type (token::TOKEN_ID, std::move (l));
 
 3705#if 201103L <= YY_CPLUSPLUS 
 3708      make_RESERVATIONS_GLOBAL (location_type l)
 
 3710        return symbol_type (token::TOKEN_RESERVATIONS_GLOBAL, std::move (l));
 
 3720#if 201103L <= YY_CPLUSPLUS 
 3723      make_RESERVATIONS_IN_SUBNET (location_type l)
 
 3725        return symbol_type (token::TOKEN_RESERVATIONS_IN_SUBNET, std::move (l));
 
 3735#if 201103L <= YY_CPLUSPLUS 
 3738      make_RESERVATIONS_OUT_OF_POOL (location_type l)
 
 3740        return symbol_type (token::TOKEN_RESERVATIONS_OUT_OF_POOL, std::move (l));
 
 3750#if 201103L <= YY_CPLUSPLUS 
 3753      make_HOST_RESERVATION_IDENTIFIERS (location_type l)
 
 3755        return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, std::move (l));
 
 3765#if 201103L <= YY_CPLUSPLUS 
 3768      make_CLIENT_CLASSES (location_type l)
 
 3770        return symbol_type (token::TOKEN_CLIENT_CLASSES, std::move (l));
 
 3780#if 201103L <= YY_CPLUSPLUS 
 3783      make_REQUIRE_CLIENT_CLASSES (location_type l)
 
 3785        return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, std::move (l));
 
 3795#if 201103L <= YY_CPLUSPLUS 
 3798      make_EVALUATE_ADDITIONAL_CLASSES (location_type l)
 
 3800        return symbol_type (token::TOKEN_EVALUATE_ADDITIONAL_CLASSES, std::move (l));
 
 3810#if 201103L <= YY_CPLUSPLUS 
 3813      make_TEST (location_type l)
 
 3815        return symbol_type (token::TOKEN_TEST, std::move (l));
 
 3825#if 201103L <= YY_CPLUSPLUS 
 3828      make_TEMPLATE_TEST (location_type l)
 
 3830        return symbol_type (token::TOKEN_TEMPLATE_TEST, std::move (l));
 
 3840#if 201103L <= YY_CPLUSPLUS 
 3843      make_ONLY_IF_REQUIRED (location_type l)
 
 3845        return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, std::move (l));
 
 3855#if 201103L <= YY_CPLUSPLUS 
 3858      make_ONLY_IN_ADDITIONAL_LIST (location_type l)
 
 3860        return symbol_type (token::TOKEN_ONLY_IN_ADDITIONAL_LIST, std::move (l));
 
 3870#if 201103L <= YY_CPLUSPLUS 
 3873      make_CLIENT_CLASS (location_type l)
 
 3875        return symbol_type (token::TOKEN_CLIENT_CLASS, std::move (l));
 
 3885#if 201103L <= YY_CPLUSPLUS 
 3888      make_POOL_ID (location_type l)
 
 3890        return symbol_type (token::TOKEN_POOL_ID, std::move (l));
 
 3900#if 201103L <= YY_CPLUSPLUS 
 3903      make_RESERVATIONS (location_type l)
 
 3905        return symbol_type (token::TOKEN_RESERVATIONS, std::move (l));
 
 3915#if 201103L <= YY_CPLUSPLUS 
 3918      make_IP_ADDRESS (location_type l)
 
 3920        return symbol_type (token::TOKEN_IP_ADDRESS, std::move (l));
 
 3930#if 201103L <= YY_CPLUSPLUS 
 3933      make_DUID (location_type l)
 
 3935        return symbol_type (token::TOKEN_DUID, std::move (l));
 
 3945#if 201103L <= YY_CPLUSPLUS 
 3948      make_HW_ADDRESS (location_type l)
 
 3950        return symbol_type (token::TOKEN_HW_ADDRESS, std::move (l));
 
 3960#if 201103L <= YY_CPLUSPLUS 
 3963      make_CIRCUIT_ID (location_type l)
 
 3965        return symbol_type (token::TOKEN_CIRCUIT_ID, std::move (l));
 
 3975#if 201103L <= YY_CPLUSPLUS 
 3978      make_CLIENT_ID (location_type l)
 
 3980        return symbol_type (token::TOKEN_CLIENT_ID, std::move (l));
 
 3990#if 201103L <= YY_CPLUSPLUS 
 3993      make_HOSTNAME (location_type l)
 
 3995        return symbol_type (token::TOKEN_HOSTNAME, std::move (l));
 
 4005#if 201103L <= YY_CPLUSPLUS 
 4008      make_FLEX_ID (location_type l)
 
 4010        return symbol_type (token::TOKEN_FLEX_ID, std::move (l));
 
 4020#if 201103L <= YY_CPLUSPLUS 
 4023      make_RELAY (location_type l)
 
 4025        return symbol_type (token::TOKEN_RELAY, std::move (l));
 
 4035#if 201103L <= YY_CPLUSPLUS 
 4038      make_IP_ADDRESSES (location_type l)
 
 4040        return symbol_type (token::TOKEN_IP_ADDRESSES, std::move (l));
 
 4050#if 201103L <= YY_CPLUSPLUS 
 4053      make_HOOKS_LIBRARIES (location_type l)
 
 4055        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 4065#if 201103L <= YY_CPLUSPLUS 
 4068      make_LIBRARY (location_type l)
 
 4070        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 4080#if 201103L <= YY_CPLUSPLUS 
 4083      make_PARAMETERS (location_type l)
 
 4085        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 4095#if 201103L <= YY_CPLUSPLUS 
 4098      make_EXPIRED_LEASES_PROCESSING (location_type l)
 
 4100        return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, std::move (l));
 
 4110#if 201103L <= YY_CPLUSPLUS 
 4113      make_RECLAIM_TIMER_WAIT_TIME (location_type l)
 
 4115        return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, std::move (l));
 
 4125#if 201103L <= YY_CPLUSPLUS 
 4128      make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (location_type l)
 
 4130        return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, std::move (l));
 
 4140#if 201103L <= YY_CPLUSPLUS 
 4143      make_HOLD_RECLAIMED_TIME (location_type l)
 
 4145        return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, std::move (l));
 
 4155#if 201103L <= YY_CPLUSPLUS 
 4158      make_MAX_RECLAIM_LEASES (location_type l)
 
 4160        return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, std::move (l));
 
 4170#if 201103L <= YY_CPLUSPLUS 
 4173      make_MAX_RECLAIM_TIME (location_type l)
 
 4175        return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, std::move (l));
 
 4185#if 201103L <= YY_CPLUSPLUS 
 4188      make_UNWARNED_RECLAIM_CYCLES (location_type l)
 
 4190        return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, std::move (l));
 
 4200#if 201103L <= YY_CPLUSPLUS 
 4203      make_DHCP4O6_PORT (location_type l)
 
 4205        return symbol_type (token::TOKEN_DHCP4O6_PORT, std::move (l));
 
 4215#if 201103L <= YY_CPLUSPLUS 
 4218      make_DHCP_MULTI_THREADING (location_type l)
 
 4220        return symbol_type (token::TOKEN_DHCP_MULTI_THREADING, std::move (l));
 
 4230#if 201103L <= YY_CPLUSPLUS 
 4233      make_ENABLE_MULTI_THREADING (location_type l)
 
 4235        return symbol_type (token::TOKEN_ENABLE_MULTI_THREADING, std::move (l));
 
 4245#if 201103L <= YY_CPLUSPLUS 
 4248      make_THREAD_POOL_SIZE (location_type l)
 
 4250        return symbol_type (token::TOKEN_THREAD_POOL_SIZE, std::move (l));
 
 4260#if 201103L <= YY_CPLUSPLUS 
 4263      make_PACKET_QUEUE_SIZE (location_type l)
 
 4265        return symbol_type (token::TOKEN_PACKET_QUEUE_SIZE, std::move (l));
 
 4275#if 201103L <= YY_CPLUSPLUS 
 4278      make_CONTROL_SOCKET (location_type l)
 
 4280        return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
 
 4290#if 201103L <= YY_CPLUSPLUS 
 4293      make_CONTROL_SOCKETS (location_type l)
 
 4295        return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
 
 4305#if 201103L <= YY_CPLUSPLUS 
 4308      make_SOCKET_TYPE (location_type l)
 
 4310        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 4320#if 201103L <= YY_CPLUSPLUS 
 4323      make_UNIX (location_type l)
 
 4325        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 4335#if 201103L <= YY_CPLUSPLUS 
 4338      make_HTTP (location_type l)
 
 4340        return symbol_type (token::TOKEN_HTTP, std::move (l));
 
 4350#if 201103L <= YY_CPLUSPLUS 
 4353      make_HTTPS (location_type l)
 
 4355        return symbol_type (token::TOKEN_HTTPS, std::move (l));
 
 4365#if 201103L <= YY_CPLUSPLUS 
 4368      make_SOCKET_NAME (location_type l)
 
 4370        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 4380#if 201103L <= YY_CPLUSPLUS 
 4383      make_SOCKET_ADDRESS (location_type l)
 
 4385        return symbol_type (token::TOKEN_SOCKET_ADDRESS, std::move (l));
 
 4395#if 201103L <= YY_CPLUSPLUS 
 4398      make_SOCKET_PORT (location_type l)
 
 4400        return symbol_type (token::TOKEN_SOCKET_PORT, std::move (l));
 
 4410#if 201103L <= YY_CPLUSPLUS 
 4413      make_AUTHENTICATION (location_type l)
 
 4415        return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
 
 4425#if 201103L <= YY_CPLUSPLUS 
 4428      make_BASIC (location_type l)
 
 4430        return symbol_type (token::TOKEN_BASIC, std::move (l));
 
 4440#if 201103L <= YY_CPLUSPLUS 
 4443      make_REALM (location_type l)
 
 4445        return symbol_type (token::TOKEN_REALM, std::move (l));
 
 4455#if 201103L <= YY_CPLUSPLUS 
 4458      make_DIRECTORY (location_type l)
 
 4460        return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
 
 4470#if 201103L <= YY_CPLUSPLUS 
 4473      make_CLIENTS (location_type l)
 
 4475        return symbol_type (token::TOKEN_CLIENTS, std::move (l));
 
 4485#if 201103L <= YY_CPLUSPLUS 
 4488      make_USER_FILE (location_type l)
 
 4490        return symbol_type (token::TOKEN_USER_FILE, std::move (l));
 
 4500#if 201103L <= YY_CPLUSPLUS 
 4503      make_PASSWORD_FILE (location_type l)
 
 4505        return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
 
 4515#if 201103L <= YY_CPLUSPLUS 
 4518      make_CERT_REQUIRED (location_type l)
 
 4520        return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
 
 4530#if 201103L <= YY_CPLUSPLUS 
 4533      make_HTTP_HEADERS (location_type l)
 
 4535        return symbol_type (token::TOKEN_HTTP_HEADERS, std::move (l));
 
 4545#if 201103L <= YY_CPLUSPLUS 
 4548      make_VALUE (location_type l)
 
 4550        return symbol_type (token::TOKEN_VALUE, std::move (l));
 
 4560#if 201103L <= YY_CPLUSPLUS 
 4563      make_DHCP_QUEUE_CONTROL (location_type l)
 
 4565        return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, std::move (l));
 
 4575#if 201103L <= YY_CPLUSPLUS 
 4578      make_ENABLE_QUEUE (location_type l)
 
 4580        return symbol_type (token::TOKEN_ENABLE_QUEUE, std::move (l));
 
 4590#if 201103L <= YY_CPLUSPLUS 
 4593      make_QUEUE_TYPE (location_type l)
 
 4595        return symbol_type (token::TOKEN_QUEUE_TYPE, std::move (l));
 
 4605#if 201103L <= YY_CPLUSPLUS 
 4608      make_CAPACITY (location_type l)
 
 4610        return symbol_type (token::TOKEN_CAPACITY, std::move (l));
 
 4620#if 201103L <= YY_CPLUSPLUS 
 4623      make_DHCP_DDNS (location_type l)
 
 4625        return symbol_type (token::TOKEN_DHCP_DDNS, std::move (l));
 
 4635#if 201103L <= YY_CPLUSPLUS 
 4638      make_ENABLE_UPDATES (location_type l)
 
 4640        return symbol_type (token::TOKEN_ENABLE_UPDATES, std::move (l));
 
 4650#if 201103L <= YY_CPLUSPLUS 
 4653      make_SERVER_IP (location_type l)
 
 4655        return symbol_type (token::TOKEN_SERVER_IP, std::move (l));
 
 4665#if 201103L <= YY_CPLUSPLUS 
 4668      make_SERVER_PORT (location_type l)
 
 4670        return symbol_type (token::TOKEN_SERVER_PORT, std::move (l));
 
 4680#if 201103L <= YY_CPLUSPLUS 
 4683      make_SENDER_IP (location_type l)
 
 4685        return symbol_type (token::TOKEN_SENDER_IP, std::move (l));
 
 4695#if 201103L <= YY_CPLUSPLUS 
 4698      make_SENDER_PORT (location_type l)
 
 4700        return symbol_type (token::TOKEN_SENDER_PORT, std::move (l));
 
 4710#if 201103L <= YY_CPLUSPLUS 
 4713      make_MAX_QUEUE_SIZE (location_type l)
 
 4715        return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, std::move (l));
 
 4725#if 201103L <= YY_CPLUSPLUS 
 4728      make_NCR_PROTOCOL (location_type l)
 
 4730        return symbol_type (token::TOKEN_NCR_PROTOCOL, std::move (l));
 
 4740#if 201103L <= YY_CPLUSPLUS 
 4743      make_NCR_FORMAT (location_type l)
 
 4745        return symbol_type (token::TOKEN_NCR_FORMAT, std::move (l));
 
 4755#if 201103L <= YY_CPLUSPLUS 
 4758      make_TCP (location_type l)
 
 4760        return symbol_type (token::TOKEN_TCP, std::move (l));
 
 4770#if 201103L <= YY_CPLUSPLUS 
 4773      make_JSON (location_type l)
 
 4775        return symbol_type (token::TOKEN_JSON, std::move (l));
 
 4785#if 201103L <= YY_CPLUSPLUS 
 4788      make_WHEN_PRESENT (location_type l)
 
 4790        return symbol_type (token::TOKEN_WHEN_PRESENT, std::move (l));
 
 4800#if 201103L <= YY_CPLUSPLUS 
 4803      make_NEVER (location_type l)
 
 4805        return symbol_type (token::TOKEN_NEVER, std::move (l));
 
 4815#if 201103L <= YY_CPLUSPLUS 
 4818      make_ALWAYS (location_type l)
 
 4820        return symbol_type (token::TOKEN_ALWAYS, std::move (l));
 
 4830#if 201103L <= YY_CPLUSPLUS 
 4833      make_WHEN_NOT_PRESENT (location_type l)
 
 4835        return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, std::move (l));
 
 4845#if 201103L <= YY_CPLUSPLUS 
 4848      make_HOSTNAME_CHAR_SET (location_type l)
 
 4850        return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, std::move (l));
 
 4860#if 201103L <= YY_CPLUSPLUS 
 4863      make_HOSTNAME_CHAR_REPLACEMENT (location_type l)
 
 4865        return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, std::move (l));
 
 4875#if 201103L <= YY_CPLUSPLUS 
 4878      make_EARLY_GLOBAL_RESERVATIONS_LOOKUP (location_type l)
 
 4880        return symbol_type (token::TOKEN_EARLY_GLOBAL_RESERVATIONS_LOOKUP, std::move (l));
 
 4890#if 201103L <= YY_CPLUSPLUS 
 4893      make_IP_RESERVATIONS_UNIQUE (location_type l)
 
 4895        return symbol_type (token::TOKEN_IP_RESERVATIONS_UNIQUE, std::move (l));
 
 4905#if 201103L <= YY_CPLUSPLUS 
 4908      make_RESERVATIONS_LOOKUP_FIRST (location_type l)
 
 4910        return symbol_type (token::TOKEN_RESERVATIONS_LOOKUP_FIRST, std::move (l));
 
 4920#if 201103L <= YY_CPLUSPLUS 
 4923      make_LOGGERS (location_type l)
 
 4925        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 4935#if 201103L <= YY_CPLUSPLUS 
 4938      make_OUTPUT_OPTIONS (location_type l)
 
 4940        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 4950#if 201103L <= YY_CPLUSPLUS 
 4953      make_OUTPUT (location_type l)
 
 4955        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 4965#if 201103L <= YY_CPLUSPLUS 
 4968      make_DEBUGLEVEL (location_type l)
 
 4970        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 4980#if 201103L <= YY_CPLUSPLUS 
 4983      make_SEVERITY (location_type l)
 
 4985        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 4995#if 201103L <= YY_CPLUSPLUS 
 4998      make_FLUSH (location_type l)
 
 5000        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 5010#if 201103L <= YY_CPLUSPLUS 
 5013      make_MAXSIZE (location_type l)
 
 5015        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 5025#if 201103L <= YY_CPLUSPLUS 
 5028      make_MAXVER (location_type l)
 
 5030        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 5040#if 201103L <= YY_CPLUSPLUS 
 5043      make_PATTERN (location_type l)
 
 5045        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 5055#if 201103L <= YY_CPLUSPLUS 
 5058      make_COMPATIBILITY (location_type l)
 
 5060        return symbol_type (token::TOKEN_COMPATIBILITY, std::move (l));
 
 5070#if 201103L <= YY_CPLUSPLUS 
 5073      make_LENIENT_OPTION_PARSING (location_type l)
 
 5075        return symbol_type (token::TOKEN_LENIENT_OPTION_PARSING, std::move (l));
 
 5085#if 201103L <= YY_CPLUSPLUS 
 5088      make_IGNORE_DHCP_SERVER_ID (location_type l)
 
 5090        return symbol_type (token::TOKEN_IGNORE_DHCP_SERVER_ID, std::move (l));
 
 5100#if 201103L <= YY_CPLUSPLUS 
 5103      make_IGNORE_RAI_LINK_SEL (location_type l)
 
 5105        return symbol_type (token::TOKEN_IGNORE_RAI_LINK_SEL, std::move (l));
 
 5115#if 201103L <= YY_CPLUSPLUS 
 5118      make_EXCLUDE_FIRST_LAST_24 (location_type l)
 
 5120        return symbol_type (token::TOKEN_EXCLUDE_FIRST_LAST_24, std::move (l));
 
 5130#if 201103L <= YY_CPLUSPLUS 
 5133      make_TOPLEVEL_JSON (location_type l)
 
 5135        return symbol_type (token::TOKEN_TOPLEVEL_JSON, std::move (l));
 
 5145#if 201103L <= YY_CPLUSPLUS 
 5148      make_TOPLEVEL_DHCP4 (location_type l)
 
 5150        return symbol_type (token::TOKEN_TOPLEVEL_DHCP4, std::move (l));
 
 5160#if 201103L <= YY_CPLUSPLUS 
 5163      make_SUB_DHCP4 (location_type l)
 
 5165        return symbol_type (token::TOKEN_SUB_DHCP4, std::move (l));
 
 5175#if 201103L <= YY_CPLUSPLUS 
 5178      make_SUB_INTERFACES4 (location_type l)
 
 5180        return symbol_type (token::TOKEN_SUB_INTERFACES4, std::move (l));
 
 5190#if 201103L <= YY_CPLUSPLUS 
 5193      make_SUB_SUBNET4 (location_type l)
 
 5195        return symbol_type (token::TOKEN_SUB_SUBNET4, std::move (l));
 
 5205#if 201103L <= YY_CPLUSPLUS 
 5208      make_SUB_POOL4 (location_type l)
 
 5210        return symbol_type (token::TOKEN_SUB_POOL4, std::move (l));
 
 5220#if 201103L <= YY_CPLUSPLUS 
 5223      make_SUB_RESERVATION (location_type l)
 
 5225        return symbol_type (token::TOKEN_SUB_RESERVATION, std::move (l));
 
 5235#if 201103L <= YY_CPLUSPLUS 
 5238      make_SUB_OPTION_DEFS (location_type l)
 
 5240        return symbol_type (token::TOKEN_SUB_OPTION_DEFS, std::move (l));
 
 5250#if 201103L <= YY_CPLUSPLUS 
 5253      make_SUB_OPTION_DEF (location_type l)
 
 5255        return symbol_type (token::TOKEN_SUB_OPTION_DEF, std::move (l));
 
 5265#if 201103L <= YY_CPLUSPLUS 
 5268      make_SUB_OPTION_DATA (location_type l)
 
 5270        return symbol_type (token::TOKEN_SUB_OPTION_DATA, std::move (l));
 
 5280#if 201103L <= YY_CPLUSPLUS 
 5283      make_SUB_HOOKS_LIBRARY (location_type l)
 
 5285        return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, std::move (l));
 
 5295#if 201103L <= YY_CPLUSPLUS 
 5298      make_SUB_DHCP_DDNS (location_type l)
 
 5300        return symbol_type (token::TOKEN_SUB_DHCP_DDNS, std::move (l));
 
 5310#if 201103L <= YY_CPLUSPLUS 
 5313      make_SUB_CONFIG_CONTROL (location_type l)
 
 5315        return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, std::move (l));
 
 5325#if 201103L <= YY_CPLUSPLUS 
 5328      make_STRING (std::string v, location_type l)
 
 5330        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 5340#if 201103L <= YY_CPLUSPLUS 
 5343      make_INTEGER (int64_t v, location_type l)
 
 5345        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 5355#if 201103L <= YY_CPLUSPLUS 
 5358      make_FLOAT (
double v, location_type l)
 
 5360        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 5370#if 201103L <= YY_CPLUSPLUS 
 5373      make_BOOLEAN (
bool v, location_type l)
 
 5375        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 5406#if YY_CPLUSPLUS < 201103L 
 5415    typedef short state_type;
 
 5418    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 5419                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 5423    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 5427    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 5431    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5435    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5437    static const short yypact_ninf_;
 
 5438    static const signed char yytable_ninf_;
 
 5443    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 5446    static std::string yytnamerr_ (
const char *yystr);
 
 5449    static const char* 
const yytname_[];
 
 5455    static const short yypact_[];
 
 5460    static const short yydefact_[];
 
 5463    static const short yypgoto_[];
 
 5466    static const short yydefgoto_[];
 
 5471    static const short yytable_[];
 
 5473    static const short yycheck_[];
 
 5477    static const short yystos_[];
 
 5480    static const short yyr1_[];
 
 5483    static const signed char yyr2_[];
 
 5488    static const short yyrline_[];
 
 5490    virtual void yy_reduce_print_ (
int r) 
const;
 
 5492    virtual void yy_stack_print_ () 
const;
 
 5497    std::ostream* yycdebug_;
 
 5502    template <
typename Base>
 
 5503    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 5510    template <
typename Base>
 
 5511    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 5521      typedef state_type kind_type;
 
 5533      void move (by_state& that);
 
 5541      enum { empty_state = 0 };
 
 5549    struct stack_symbol_type : basic_symbol<by_state>
 
 5552      typedef basic_symbol<by_state> super_type;
 
 5554      stack_symbol_type ();
 
 5556      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 5558      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 5559#if YY_CPLUSPLUS < 201103L 
 5562      stack_symbol_type& operator= (stack_symbol_type& that);
 
 5566      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 5571    template <
typename T, 
typename S = std::vector<T> >
 
 5576      typedef typename S::iterator iterator;
 
 5577      typedef typename S::const_iterator const_iterator;
 
 5578      typedef typename S::size_type size_type;
 
 5579      typedef typename std::ptrdiff_t index_type;
 
 5585#if 201103L <= YY_CPLUSPLUS 
 5587      stack (
const stack&) = 
delete;
 
 5589      stack& operator= (
const stack&) = 
delete;
 
 5596      operator[] (index_type i)
 const 
 5598        return seq_[size_type (size () - 1 - i)];
 
 5605      operator[] (index_type i)
 
 5607        return seq_[size_type (size () - 1 - i)];
 
 5616        seq_.push_back (T ());
 
 5617        operator[] (0).move (t);
 
 5639        return index_type (seq_.size ());
 
 5646        return seq_.begin ();
 
 5666        operator[] (index_type i)
 const 
 5668          return stack_[range_ - i];
 
 
 5672        const stack& stack_;
 
 
 5677#if YY_CPLUSPLUS < 201103L 
 5679      stack (
const stack&);
 
 5681      stack& operator= (
const stack&);
 
 5689    typedef stack<stack_symbol_type> stack_type;
 
 5692    stack_type yystack_;
 
 5699    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 5707    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);