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);
 
  442      char dummy2[
sizeof (bool)];
 
  445      char dummy3[
sizeof (double)];
 
  448      char dummy4[
sizeof (int64_t)];
 
  451      char dummy5[
sizeof (std::string)];
 
  455    enum { size = 
sizeof (union_type) };
 
  467    const std::type_info *yytypeid_;
 
 
  481        : std::runtime_error (m)
 
 
  486        : std::runtime_error (s.what ())
 
 
 
 1497    template <
typename Base>
 
 1509#if 201103L <= YY_CPLUSPLUS 
 1512        : Base (std::move (that))
 
 1514        , location (std::move (that.location))
 
 1516        switch (this->kind ())
 
 1529        value.move< 
ElementPtr > (std::move (that.value));
 
 1533        value.move< 
bool > (std::move (that.value));
 
 1537        value.move< 
double > (std::move (that.value));
 
 1541        value.move< int64_t > (std::move (that.value));
 
 1545        value.move< std::string > (std::move (that.value));
 
 1559#if 201103L <= YY_CPLUSPLUS 
 1571#if 201103L <= YY_CPLUSPLUS 
 1574        , value (std::move (v))
 
 1575        , location (std::move (l))
 
 1585#if 201103L <= YY_CPLUSPLUS 
 1588        , value (std::move (v))
 
 1589        , location (std::move (l))
 
 1599#if 201103L <= YY_CPLUSPLUS 
 1602        , value (std::move (v))
 
 1603        , location (std::move (l))
 
 1613#if 201103L <= YY_CPLUSPLUS 
 1616        , value (std::move (v))
 
 1617        , location (std::move (l))
 
 1627#if 201103L <= YY_CPLUSPLUS 
 1630        , value (std::move (v))
 
 1631        , location (std::move (l))
 
 1676        value.template destroy< ElementPtr > ();
 
 1680        value.template destroy< bool > ();
 
 1684        value.template destroy< double > ();
 
 1688        value.template destroy< int64_t > ();
 
 1692        value.template destroy< std::string > ();
 
 
 1724#if YY_CPLUSPLUS < 201103L 
 
 1739#if 201103L <= YY_CPLUSPLUS 
 
 1783#if 201103L <= YY_CPLUSPLUS 
 1791#if !defined _MSC_VER || defined __clang__ 
 
 1796#if 201103L <= YY_CPLUSPLUS 
 1804#if !defined _MSC_VER || defined __clang__ 
 
 1808#if 201103L <= YY_CPLUSPLUS 
 1816#if !defined _MSC_VER || defined __clang__ 
 
 1820#if 201103L <= YY_CPLUSPLUS 
 1828#if !defined _MSC_VER || defined __clang__ 
 
 1832#if 201103L <= YY_CPLUSPLUS 
 1840#if !defined _MSC_VER || defined __clang__ 
 
 
 1850#if 201103L <= YY_CPLUSPLUS 
 1863    virtual int parse ();
 
 1869    void set_debug_stream (std::ostream &);
 
 1872    typedef 
int debug_level_type;
 
 1876    void set_debug_level (debug_level_type l);
 
 1882    virtual void error (
const location_type& loc, 
const std::string& msg);
 
 1885    void error (
const syntax_error& err);
 
 1889    static std::string symbol_name (symbol_kind_type yysymbol);
 
 1892#if 201103L <= YY_CPLUSPLUS 
 1895      make_END (location_type l)
 
 1897        return symbol_type (token::TOKEN_END, std::move (l));
 
 1907#if 201103L <= YY_CPLUSPLUS 
 1910      make_PARSER4_error (location_type l)
 
 1912        return symbol_type (token::TOKEN_PARSER4_error, std::move (l));
 
 1922#if 201103L <= YY_CPLUSPLUS 
 1925      make_PARSER4_UNDEF (location_type l)
 
 1927        return symbol_type (token::TOKEN_PARSER4_UNDEF, std::move (l));
 
 1937#if 201103L <= YY_CPLUSPLUS 
 1940      make_COMMA (location_type l)
 
 1942        return symbol_type (token::TOKEN_COMMA, std::move (l));
 
 1952#if 201103L <= YY_CPLUSPLUS 
 1955      make_COLON (location_type l)
 
 1957        return symbol_type (token::TOKEN_COLON, std::move (l));
 
 1967#if 201103L <= YY_CPLUSPLUS 
 1970      make_LSQUARE_BRACKET (location_type l)
 
 1972        return symbol_type (token::TOKEN_LSQUARE_BRACKET, std::move (l));
 
 1982#if 201103L <= YY_CPLUSPLUS 
 1985      make_RSQUARE_BRACKET (location_type l)
 
 1987        return symbol_type (token::TOKEN_RSQUARE_BRACKET, std::move (l));
 
 1997#if 201103L <= YY_CPLUSPLUS 
 2000      make_LCURLY_BRACKET (location_type l)
 
 2002        return symbol_type (token::TOKEN_LCURLY_BRACKET, std::move (l));
 
 2012#if 201103L <= YY_CPLUSPLUS 
 2015      make_RCURLY_BRACKET (location_type l)
 
 2017        return symbol_type (token::TOKEN_RCURLY_BRACKET, std::move (l));
 
 2027#if 201103L <= YY_CPLUSPLUS 
 2030      make_NULL_TYPE (location_type l)
 
 2032        return symbol_type (token::TOKEN_NULL_TYPE, std::move (l));
 
 2042#if 201103L <= YY_CPLUSPLUS 
 2045      make_DHCP4 (location_type l)
 
 2047        return symbol_type (token::TOKEN_DHCP4, std::move (l));
 
 2057#if 201103L <= YY_CPLUSPLUS 
 2060      make_CONFIG_CONTROL (location_type l)
 
 2062        return symbol_type (token::TOKEN_CONFIG_CONTROL, std::move (l));
 
 2072#if 201103L <= YY_CPLUSPLUS 
 2075      make_CONFIG_DATABASES (location_type l)
 
 2077        return symbol_type (token::TOKEN_CONFIG_DATABASES, std::move (l));
 
 2087#if 201103L <= YY_CPLUSPLUS 
 2090      make_CONFIG_FETCH_WAIT_TIME (location_type l)
 
 2092        return symbol_type (token::TOKEN_CONFIG_FETCH_WAIT_TIME, std::move (l));
 
 2102#if 201103L <= YY_CPLUSPLUS 
 2105      make_INTERFACES_CONFIG (location_type l)
 
 2107        return symbol_type (token::TOKEN_INTERFACES_CONFIG, std::move (l));
 
 2117#if 201103L <= YY_CPLUSPLUS 
 2120      make_INTERFACES (location_type l)
 
 2122        return symbol_type (token::TOKEN_INTERFACES, std::move (l));
 
 2132#if 201103L <= YY_CPLUSPLUS 
 2135      make_DHCP_SOCKET_TYPE (location_type l)
 
 2137        return symbol_type (token::TOKEN_DHCP_SOCKET_TYPE, std::move (l));
 
 2147#if 201103L <= YY_CPLUSPLUS 
 2150      make_RAW (location_type l)
 
 2152        return symbol_type (token::TOKEN_RAW, std::move (l));
 
 2162#if 201103L <= YY_CPLUSPLUS 
 2165      make_UDP (location_type l)
 
 2167        return symbol_type (token::TOKEN_UDP, std::move (l));
 
 2177#if 201103L <= YY_CPLUSPLUS 
 2180      make_OUTBOUND_INTERFACE (location_type l)
 
 2182        return symbol_type (token::TOKEN_OUTBOUND_INTERFACE, std::move (l));
 
 2192#if 201103L <= YY_CPLUSPLUS 
 2195      make_SAME_AS_INBOUND (location_type l)
 
 2197        return symbol_type (token::TOKEN_SAME_AS_INBOUND, std::move (l));
 
 2207#if 201103L <= YY_CPLUSPLUS 
 2210      make_USE_ROUTING (location_type l)
 
 2212        return symbol_type (token::TOKEN_USE_ROUTING, std::move (l));
 
 2222#if 201103L <= YY_CPLUSPLUS 
 2225      make_RE_DETECT (location_type l)
 
 2227        return symbol_type (token::TOKEN_RE_DETECT, std::move (l));
 
 2237#if 201103L <= YY_CPLUSPLUS 
 2240      make_SERVICE_SOCKETS_REQUIRE_ALL (location_type l)
 
 2242        return symbol_type (token::TOKEN_SERVICE_SOCKETS_REQUIRE_ALL, std::move (l));
 
 2252#if 201103L <= YY_CPLUSPLUS 
 2255      make_SERVICE_SOCKETS_RETRY_WAIT_TIME (location_type l)
 
 2257        return symbol_type (token::TOKEN_SERVICE_SOCKETS_RETRY_WAIT_TIME, std::move (l));
 
 2267#if 201103L <= YY_CPLUSPLUS 
 2270      make_SERVICE_SOCKETS_MAX_RETRIES (location_type l)
 
 2272        return symbol_type (token::TOKEN_SERVICE_SOCKETS_MAX_RETRIES, std::move (l));
 
 2282#if 201103L <= YY_CPLUSPLUS 
 2285      make_SANITY_CHECKS (location_type l)
 
 2287        return symbol_type (token::TOKEN_SANITY_CHECKS, std::move (l));
 
 2297#if 201103L <= YY_CPLUSPLUS 
 2300      make_LEASE_CHECKS (location_type l)
 
 2302        return symbol_type (token::TOKEN_LEASE_CHECKS, std::move (l));
 
 2312#if 201103L <= YY_CPLUSPLUS 
 2315      make_EXTENDED_INFO_CHECKS (location_type l)
 
 2317        return symbol_type (token::TOKEN_EXTENDED_INFO_CHECKS, std::move (l));
 
 2327#if 201103L <= YY_CPLUSPLUS 
 2330      make_ECHO_CLIENT_ID (location_type l)
 
 2332        return symbol_type (token::TOKEN_ECHO_CLIENT_ID, std::move (l));
 
 2342#if 201103L <= YY_CPLUSPLUS 
 2345      make_MATCH_CLIENT_ID (location_type l)
 
 2347        return symbol_type (token::TOKEN_MATCH_CLIENT_ID, std::move (l));
 
 2357#if 201103L <= YY_CPLUSPLUS 
 2360      make_AUTHORITATIVE (location_type l)
 
 2362        return symbol_type (token::TOKEN_AUTHORITATIVE, std::move (l));
 
 2372#if 201103L <= YY_CPLUSPLUS 
 2375      make_NEXT_SERVER (location_type l)
 
 2377        return symbol_type (token::TOKEN_NEXT_SERVER, std::move (l));
 
 2387#if 201103L <= YY_CPLUSPLUS 
 2390      make_SERVER_HOSTNAME (location_type l)
 
 2392        return symbol_type (token::TOKEN_SERVER_HOSTNAME, std::move (l));
 
 2402#if 201103L <= YY_CPLUSPLUS 
 2405      make_BOOT_FILE_NAME (location_type l)
 
 2407        return symbol_type (token::TOKEN_BOOT_FILE_NAME, std::move (l));
 
 2417#if 201103L <= YY_CPLUSPLUS 
 2420      make_OFFER_LFT (location_type l)
 
 2422        return symbol_type (token::TOKEN_OFFER_LFT, std::move (l));
 
 2432#if 201103L <= YY_CPLUSPLUS 
 2435      make_STASH_AGENT_OPTIONS (location_type l)
 
 2437        return symbol_type (token::TOKEN_STASH_AGENT_OPTIONS, std::move (l));
 
 2447#if 201103L <= YY_CPLUSPLUS 
 2450      make_LEASE_DATABASE (location_type l)
 
 2452        return symbol_type (token::TOKEN_LEASE_DATABASE, std::move (l));
 
 2462#if 201103L <= YY_CPLUSPLUS 
 2465      make_HOSTS_DATABASE (location_type l)
 
 2467        return symbol_type (token::TOKEN_HOSTS_DATABASE, std::move (l));
 
 2477#if 201103L <= YY_CPLUSPLUS 
 2480      make_HOSTS_DATABASES (location_type l)
 
 2482        return symbol_type (token::TOKEN_HOSTS_DATABASES, std::move (l));
 
 2492#if 201103L <= YY_CPLUSPLUS 
 2495      make_TYPE (location_type l)
 
 2497        return symbol_type (token::TOKEN_TYPE, std::move (l));
 
 2507#if 201103L <= YY_CPLUSPLUS 
 2510      make_USER (location_type l)
 
 2512        return symbol_type (token::TOKEN_USER, std::move (l));
 
 2522#if 201103L <= YY_CPLUSPLUS 
 2525      make_PASSWORD (location_type l)
 
 2527        return symbol_type (token::TOKEN_PASSWORD, std::move (l));
 
 2537#if 201103L <= YY_CPLUSPLUS 
 2540      make_HOST (location_type l)
 
 2542        return symbol_type (token::TOKEN_HOST, std::move (l));
 
 2552#if 201103L <= YY_CPLUSPLUS 
 2555      make_PORT (location_type l)
 
 2557        return symbol_type (token::TOKEN_PORT, std::move (l));
 
 2567#if 201103L <= YY_CPLUSPLUS 
 2570      make_PERSIST (location_type l)
 
 2572        return symbol_type (token::TOKEN_PERSIST, std::move (l));
 
 2582#if 201103L <= YY_CPLUSPLUS 
 2585      make_LFC_INTERVAL (location_type l)
 
 2587        return symbol_type (token::TOKEN_LFC_INTERVAL, std::move (l));
 
 2597#if 201103L <= YY_CPLUSPLUS 
 2600      make_READONLY (location_type l)
 
 2602        return symbol_type (token::TOKEN_READONLY, std::move (l));
 
 2612#if 201103L <= YY_CPLUSPLUS 
 2615      make_CONNECT_TIMEOUT (location_type l)
 
 2617        return symbol_type (token::TOKEN_CONNECT_TIMEOUT, std::move (l));
 
 2627#if 201103L <= YY_CPLUSPLUS 
 2630      make_READ_TIMEOUT (location_type l)
 
 2632        return symbol_type (token::TOKEN_READ_TIMEOUT, std::move (l));
 
 2642#if 201103L <= YY_CPLUSPLUS 
 2645      make_WRITE_TIMEOUT (location_type l)
 
 2647        return symbol_type (token::TOKEN_WRITE_TIMEOUT, std::move (l));
 
 2657#if 201103L <= YY_CPLUSPLUS 
 2660      make_TCP_USER_TIMEOUT (location_type l)
 
 2662        return symbol_type (token::TOKEN_TCP_USER_TIMEOUT, std::move (l));
 
 2672#if 201103L <= YY_CPLUSPLUS 
 2675      make_MAX_RECONNECT_TRIES (location_type l)
 
 2677        return symbol_type (token::TOKEN_MAX_RECONNECT_TRIES, std::move (l));
 
 2687#if 201103L <= YY_CPLUSPLUS 
 2690      make_RECONNECT_WAIT_TIME (location_type l)
 
 2692        return symbol_type (token::TOKEN_RECONNECT_WAIT_TIME, std::move (l));
 
 2702#if 201103L <= YY_CPLUSPLUS 
 2705      make_ON_FAIL (location_type l)
 
 2707        return symbol_type (token::TOKEN_ON_FAIL, std::move (l));
 
 2717#if 201103L <= YY_CPLUSPLUS 
 2720      make_STOP_RETRY_EXIT (location_type l)
 
 2722        return symbol_type (token::TOKEN_STOP_RETRY_EXIT, std::move (l));
 
 2732#if 201103L <= YY_CPLUSPLUS 
 2735      make_SERVE_RETRY_EXIT (location_type l)
 
 2737        return symbol_type (token::TOKEN_SERVE_RETRY_EXIT, std::move (l));
 
 2747#if 201103L <= YY_CPLUSPLUS 
 2750      make_SERVE_RETRY_CONTINUE (location_type l)
 
 2752        return symbol_type (token::TOKEN_SERVE_RETRY_CONTINUE, std::move (l));
 
 2762#if 201103L <= YY_CPLUSPLUS 
 2765      make_RETRY_ON_STARTUP (location_type l)
 
 2767        return symbol_type (token::TOKEN_RETRY_ON_STARTUP, std::move (l));
 
 2777#if 201103L <= YY_CPLUSPLUS 
 2780      make_MAX_ROW_ERRORS (location_type l)
 
 2782        return symbol_type (token::TOKEN_MAX_ROW_ERRORS, std::move (l));
 
 2792#if 201103L <= YY_CPLUSPLUS 
 2795      make_TRUST_ANCHOR (location_type l)
 
 2797        return symbol_type (token::TOKEN_TRUST_ANCHOR, std::move (l));
 
 2807#if 201103L <= YY_CPLUSPLUS 
 2810      make_CERT_FILE (location_type l)
 
 2812        return symbol_type (token::TOKEN_CERT_FILE, std::move (l));
 
 2822#if 201103L <= YY_CPLUSPLUS 
 2825      make_KEY_FILE (location_type l)
 
 2827        return symbol_type (token::TOKEN_KEY_FILE, std::move (l));
 
 2837#if 201103L <= YY_CPLUSPLUS 
 2840      make_SSL_MODE (location_type l)
 
 2842        return symbol_type (token::TOKEN_SSL_MODE, std::move (l));
 
 2852#if 201103L <= YY_CPLUSPLUS 
 2855      make_DISABLE (location_type l)
 
 2857        return symbol_type (token::TOKEN_DISABLE, std::move (l));
 
 2867#if 201103L <= YY_CPLUSPLUS 
 2870      make_PREFER (location_type l)
 
 2872        return symbol_type (token::TOKEN_PREFER, std::move (l));
 
 2882#if 201103L <= YY_CPLUSPLUS 
 2885      make_REQUIRE (location_type l)
 
 2887        return symbol_type (token::TOKEN_REQUIRE, std::move (l));
 
 2897#if 201103L <= YY_CPLUSPLUS 
 2900      make_VERIFY_CA (location_type l)
 
 2902        return symbol_type (token::TOKEN_VERIFY_CA, std::move (l));
 
 2912#if 201103L <= YY_CPLUSPLUS 
 2915      make_VERIFY_FULL (location_type l)
 
 2917        return symbol_type (token::TOKEN_VERIFY_FULL, std::move (l));
 
 2927#if 201103L <= YY_CPLUSPLUS 
 2930      make_CIPHER_LIST (location_type l)
 
 2932        return symbol_type (token::TOKEN_CIPHER_LIST, std::move (l));
 
 2942#if 201103L <= YY_CPLUSPLUS 
 2945      make_VALID_LIFETIME (location_type l)
 
 2947        return symbol_type (token::TOKEN_VALID_LIFETIME, std::move (l));
 
 2957#if 201103L <= YY_CPLUSPLUS 
 2960      make_MIN_VALID_LIFETIME (location_type l)
 
 2962        return symbol_type (token::TOKEN_MIN_VALID_LIFETIME, std::move (l));
 
 2972#if 201103L <= YY_CPLUSPLUS 
 2975      make_MAX_VALID_LIFETIME (location_type l)
 
 2977        return symbol_type (token::TOKEN_MAX_VALID_LIFETIME, std::move (l));
 
 2987#if 201103L <= YY_CPLUSPLUS 
 2990      make_RENEW_TIMER (location_type l)
 
 2992        return symbol_type (token::TOKEN_RENEW_TIMER, std::move (l));
 
 3002#if 201103L <= YY_CPLUSPLUS 
 3005      make_REBIND_TIMER (location_type l)
 
 3007        return symbol_type (token::TOKEN_REBIND_TIMER, std::move (l));
 
 3017#if 201103L <= YY_CPLUSPLUS 
 3020      make_CALCULATE_TEE_TIMES (location_type l)
 
 3022        return symbol_type (token::TOKEN_CALCULATE_TEE_TIMES, std::move (l));
 
 3032#if 201103L <= YY_CPLUSPLUS 
 3035      make_T1_PERCENT (location_type l)
 
 3037        return symbol_type (token::TOKEN_T1_PERCENT, std::move (l));
 
 3047#if 201103L <= YY_CPLUSPLUS 
 3050      make_T2_PERCENT (location_type l)
 
 3052        return symbol_type (token::TOKEN_T2_PERCENT, std::move (l));
 
 3062#if 201103L <= YY_CPLUSPLUS 
 3065      make_CACHE_THRESHOLD (location_type l)
 
 3067        return symbol_type (token::TOKEN_CACHE_THRESHOLD, std::move (l));
 
 3077#if 201103L <= YY_CPLUSPLUS 
 3080      make_CACHE_MAX_AGE (location_type l)
 
 3082        return symbol_type (token::TOKEN_CACHE_MAX_AGE, std::move (l));
 
 3092#if 201103L <= YY_CPLUSPLUS 
 3095      make_DECLINE_PROBATION_PERIOD (location_type l)
 
 3097        return symbol_type (token::TOKEN_DECLINE_PROBATION_PERIOD, std::move (l));
 
 3107#if 201103L <= YY_CPLUSPLUS 
 3110      make_SERVER_TAG (location_type l)
 
 3112        return symbol_type (token::TOKEN_SERVER_TAG, std::move (l));
 
 3122#if 201103L <= YY_CPLUSPLUS 
 3125      make_STATISTIC_DEFAULT_SAMPLE_COUNT (location_type l)
 
 3127        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_COUNT, std::move (l));
 
 3137#if 201103L <= YY_CPLUSPLUS 
 3140      make_STATISTIC_DEFAULT_SAMPLE_AGE (location_type l)
 
 3142        return symbol_type (token::TOKEN_STATISTIC_DEFAULT_SAMPLE_AGE, std::move (l));
 
 3152#if 201103L <= YY_CPLUSPLUS 
 3155      make_DDNS_SEND_UPDATES (location_type l)
 
 3157        return symbol_type (token::TOKEN_DDNS_SEND_UPDATES, std::move (l));
 
 3167#if 201103L <= YY_CPLUSPLUS 
 3170      make_DDNS_OVERRIDE_NO_UPDATE (location_type l)
 
 3172        return symbol_type (token::TOKEN_DDNS_OVERRIDE_NO_UPDATE, std::move (l));
 
 3182#if 201103L <= YY_CPLUSPLUS 
 3185      make_DDNS_OVERRIDE_CLIENT_UPDATE (location_type l)
 
 3187        return symbol_type (token::TOKEN_DDNS_OVERRIDE_CLIENT_UPDATE, std::move (l));
 
 3197#if 201103L <= YY_CPLUSPLUS 
 3200      make_DDNS_REPLACE_CLIENT_NAME (location_type l)
 
 3202        return symbol_type (token::TOKEN_DDNS_REPLACE_CLIENT_NAME, std::move (l));
 
 3212#if 201103L <= YY_CPLUSPLUS 
 3215      make_DDNS_GENERATED_PREFIX (location_type l)
 
 3217        return symbol_type (token::TOKEN_DDNS_GENERATED_PREFIX, std::move (l));
 
 3227#if 201103L <= YY_CPLUSPLUS 
 3230      make_DDNS_QUALIFYING_SUFFIX (location_type l)
 
 3232        return symbol_type (token::TOKEN_DDNS_QUALIFYING_SUFFIX, std::move (l));
 
 3242#if 201103L <= YY_CPLUSPLUS 
 3245      make_DDNS_UPDATE_ON_RENEW (location_type l)
 
 3247        return symbol_type (token::TOKEN_DDNS_UPDATE_ON_RENEW, std::move (l));
 
 3257#if 201103L <= YY_CPLUSPLUS 
 3260      make_DDNS_USE_CONFLICT_RESOLUTION (location_type l)
 
 3262        return symbol_type (token::TOKEN_DDNS_USE_CONFLICT_RESOLUTION, std::move (l));
 
 3272#if 201103L <= YY_CPLUSPLUS 
 3275      make_DDNS_TTL_PERCENT (location_type l)
 
 3277        return symbol_type (token::TOKEN_DDNS_TTL_PERCENT, std::move (l));
 
 3287#if 201103L <= YY_CPLUSPLUS 
 3290      make_DDNS_TTL (location_type l)
 
 3292        return symbol_type (token::TOKEN_DDNS_TTL, std::move (l));
 
 3302#if 201103L <= YY_CPLUSPLUS 
 3305      make_DDNS_TTL_MIN (location_type l)
 
 3307        return symbol_type (token::TOKEN_DDNS_TTL_MIN, std::move (l));
 
 3317#if 201103L <= YY_CPLUSPLUS 
 3320      make_DDNS_TTL_MAX (location_type l)
 
 3322        return symbol_type (token::TOKEN_DDNS_TTL_MAX, std::move (l));
 
 3332#if 201103L <= YY_CPLUSPLUS 
 3335      make_STORE_EXTENDED_INFO (location_type l)
 
 3337        return symbol_type (token::TOKEN_STORE_EXTENDED_INFO, std::move (l));
 
 3347#if 201103L <= YY_CPLUSPLUS 
 3350      make_SUBNET4 (location_type l)
 
 3352        return symbol_type (token::TOKEN_SUBNET4, std::move (l));
 
 3362#if 201103L <= YY_CPLUSPLUS 
 3365      make_SUBNET_4O6_INTERFACE (location_type l)
 
 3367        return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE, std::move (l));
 
 3377#if 201103L <= YY_CPLUSPLUS 
 3380      make_SUBNET_4O6_INTERFACE_ID (location_type l)
 
 3382        return symbol_type (token::TOKEN_SUBNET_4O6_INTERFACE_ID, std::move (l));
 
 3392#if 201103L <= YY_CPLUSPLUS 
 3395      make_SUBNET_4O6_SUBNET (location_type l)
 
 3397        return symbol_type (token::TOKEN_SUBNET_4O6_SUBNET, std::move (l));
 
 3407#if 201103L <= YY_CPLUSPLUS 
 3410      make_OPTION_DEF (location_type l)
 
 3412        return symbol_type (token::TOKEN_OPTION_DEF, std::move (l));
 
 3422#if 201103L <= YY_CPLUSPLUS 
 3425      make_OPTION_DATA (location_type l)
 
 3427        return symbol_type (token::TOKEN_OPTION_DATA, std::move (l));
 
 3437#if 201103L <= YY_CPLUSPLUS 
 3440      make_NAME (location_type l)
 
 3442        return symbol_type (token::TOKEN_NAME, std::move (l));
 
 3452#if 201103L <= YY_CPLUSPLUS 
 3455      make_DATA (location_type l)
 
 3457        return symbol_type (token::TOKEN_DATA, std::move (l));
 
 3467#if 201103L <= YY_CPLUSPLUS 
 3470      make_CODE (location_type l)
 
 3472        return symbol_type (token::TOKEN_CODE, std::move (l));
 
 3482#if 201103L <= YY_CPLUSPLUS 
 3485      make_SPACE (location_type l)
 
 3487        return symbol_type (token::TOKEN_SPACE, std::move (l));
 
 3497#if 201103L <= YY_CPLUSPLUS 
 3500      make_CSV_FORMAT (location_type l)
 
 3502        return symbol_type (token::TOKEN_CSV_FORMAT, std::move (l));
 
 3512#if 201103L <= YY_CPLUSPLUS 
 3515      make_ALWAYS_SEND (location_type l)
 
 3517        return symbol_type (token::TOKEN_ALWAYS_SEND, std::move (l));
 
 3527#if 201103L <= YY_CPLUSPLUS 
 3530      make_NEVER_SEND (location_type l)
 
 3532        return symbol_type (token::TOKEN_NEVER_SEND, std::move (l));
 
 3542#if 201103L <= YY_CPLUSPLUS 
 3545      make_RECORD_TYPES (location_type l)
 
 3547        return symbol_type (token::TOKEN_RECORD_TYPES, std::move (l));
 
 3557#if 201103L <= YY_CPLUSPLUS 
 3560      make_ENCAPSULATE (location_type l)
 
 3562        return symbol_type (token::TOKEN_ENCAPSULATE, std::move (l));
 
 3572#if 201103L <= YY_CPLUSPLUS 
 3575      make_ARRAY (location_type l)
 
 3577        return symbol_type (token::TOKEN_ARRAY, std::move (l));
 
 3587#if 201103L <= YY_CPLUSPLUS 
 3590      make_PARKED_PACKET_LIMIT (location_type l)
 
 3592        return symbol_type (token::TOKEN_PARKED_PACKET_LIMIT, std::move (l));
 
 3602#if 201103L <= YY_CPLUSPLUS 
 3605      make_ALLOCATOR (location_type l)
 
 3607        return symbol_type (token::TOKEN_ALLOCATOR, std::move (l));
 
 3617#if 201103L <= YY_CPLUSPLUS 
 3620      make_DDNS_CONFLICT_RESOLUTION_MODE (location_type l)
 
 3622        return symbol_type (token::TOKEN_DDNS_CONFLICT_RESOLUTION_MODE, std::move (l));
 
 3632#if 201103L <= YY_CPLUSPLUS 
 3635      make_CHECK_WITH_DHCID (location_type l)
 
 3637        return symbol_type (token::TOKEN_CHECK_WITH_DHCID, std::move (l));
 
 3647#if 201103L <= YY_CPLUSPLUS 
 3650      make_NO_CHECK_WITH_DHCID (location_type l)
 
 3652        return symbol_type (token::TOKEN_NO_CHECK_WITH_DHCID, std::move (l));
 
 3662#if 201103L <= YY_CPLUSPLUS 
 3665      make_CHECK_EXISTS_WITH_DHCID (location_type l)
 
 3667        return symbol_type (token::TOKEN_CHECK_EXISTS_WITH_DHCID, std::move (l));
 
 3677#if 201103L <= YY_CPLUSPLUS 
 3680      make_NO_CHECK_WITHOUT_DHCID (location_type l)
 
 3682        return symbol_type (token::TOKEN_NO_CHECK_WITHOUT_DHCID, std::move (l));
 
 3692#if 201103L <= YY_CPLUSPLUS 
 3695      make_SHARED_NETWORKS (location_type l)
 
 3697        return symbol_type (token::TOKEN_SHARED_NETWORKS, std::move (l));
 
 3707#if 201103L <= YY_CPLUSPLUS 
 3710      make_POOLS (location_type l)
 
 3712        return symbol_type (token::TOKEN_POOLS, std::move (l));
 
 3722#if 201103L <= YY_CPLUSPLUS 
 3725      make_POOL (location_type l)
 
 3727        return symbol_type (token::TOKEN_POOL, std::move (l));
 
 3737#if 201103L <= YY_CPLUSPLUS 
 3740      make_USER_CONTEXT (location_type l)
 
 3742        return symbol_type (token::TOKEN_USER_CONTEXT, std::move (l));
 
 3752#if 201103L <= YY_CPLUSPLUS 
 3755      make_COMMENT (location_type l)
 
 3757        return symbol_type (token::TOKEN_COMMENT, std::move (l));
 
 3767#if 201103L <= YY_CPLUSPLUS 
 3770      make_SUBNET (location_type l)
 
 3772        return symbol_type (token::TOKEN_SUBNET, std::move (l));
 
 3782#if 201103L <= YY_CPLUSPLUS 
 3785      make_INTERFACE (location_type l)
 
 3787        return symbol_type (token::TOKEN_INTERFACE, std::move (l));
 
 3797#if 201103L <= YY_CPLUSPLUS 
 3800      make_ID (location_type l)
 
 3802        return symbol_type (token::TOKEN_ID, std::move (l));
 
 3812#if 201103L <= YY_CPLUSPLUS 
 3815      make_RESERVATIONS_GLOBAL (location_type l)
 
 3817        return symbol_type (token::TOKEN_RESERVATIONS_GLOBAL, std::move (l));
 
 3827#if 201103L <= YY_CPLUSPLUS 
 3830      make_RESERVATIONS_IN_SUBNET (location_type l)
 
 3832        return symbol_type (token::TOKEN_RESERVATIONS_IN_SUBNET, std::move (l));
 
 3842#if 201103L <= YY_CPLUSPLUS 
 3845      make_RESERVATIONS_OUT_OF_POOL (location_type l)
 
 3847        return symbol_type (token::TOKEN_RESERVATIONS_OUT_OF_POOL, std::move (l));
 
 3857#if 201103L <= YY_CPLUSPLUS 
 3860      make_HOST_RESERVATION_IDENTIFIERS (location_type l)
 
 3862        return symbol_type (token::TOKEN_HOST_RESERVATION_IDENTIFIERS, std::move (l));
 
 3872#if 201103L <= YY_CPLUSPLUS 
 3875      make_CLIENT_CLASSES (location_type l)
 
 3877        return symbol_type (token::TOKEN_CLIENT_CLASSES, std::move (l));
 
 3887#if 201103L <= YY_CPLUSPLUS 
 3890      make_REQUIRE_CLIENT_CLASSES (location_type l)
 
 3892        return symbol_type (token::TOKEN_REQUIRE_CLIENT_CLASSES, std::move (l));
 
 3902#if 201103L <= YY_CPLUSPLUS 
 3905      make_EVALUATE_ADDITIONAL_CLASSES (location_type l)
 
 3907        return symbol_type (token::TOKEN_EVALUATE_ADDITIONAL_CLASSES, std::move (l));
 
 3917#if 201103L <= YY_CPLUSPLUS 
 3920      make_TEST (location_type l)
 
 3922        return symbol_type (token::TOKEN_TEST, std::move (l));
 
 3932#if 201103L <= YY_CPLUSPLUS 
 3935      make_TEMPLATE_TEST (location_type l)
 
 3937        return symbol_type (token::TOKEN_TEMPLATE_TEST, std::move (l));
 
 3947#if 201103L <= YY_CPLUSPLUS 
 3950      make_ONLY_IF_REQUIRED (location_type l)
 
 3952        return symbol_type (token::TOKEN_ONLY_IF_REQUIRED, std::move (l));
 
 3962#if 201103L <= YY_CPLUSPLUS 
 3965      make_ONLY_IN_ADDITIONAL_LIST (location_type l)
 
 3967        return symbol_type (token::TOKEN_ONLY_IN_ADDITIONAL_LIST, std::move (l));
 
 3977#if 201103L <= YY_CPLUSPLUS 
 3980      make_CLIENT_CLASS (location_type l)
 
 3982        return symbol_type (token::TOKEN_CLIENT_CLASS, std::move (l));
 
 3992#if 201103L <= YY_CPLUSPLUS 
 3995      make_POOL_ID (location_type l)
 
 3997        return symbol_type (token::TOKEN_POOL_ID, std::move (l));
 
 4007#if 201103L <= YY_CPLUSPLUS 
 4010      make_RESERVATIONS (location_type l)
 
 4012        return symbol_type (token::TOKEN_RESERVATIONS, std::move (l));
 
 4022#if 201103L <= YY_CPLUSPLUS 
 4025      make_IP_ADDRESS (location_type l)
 
 4027        return symbol_type (token::TOKEN_IP_ADDRESS, std::move (l));
 
 4037#if 201103L <= YY_CPLUSPLUS 
 4040      make_DUID (location_type l)
 
 4042        return symbol_type (token::TOKEN_DUID, std::move (l));
 
 4052#if 201103L <= YY_CPLUSPLUS 
 4055      make_HW_ADDRESS (location_type l)
 
 4057        return symbol_type (token::TOKEN_HW_ADDRESS, std::move (l));
 
 4067#if 201103L <= YY_CPLUSPLUS 
 4070      make_CIRCUIT_ID (location_type l)
 
 4072        return symbol_type (token::TOKEN_CIRCUIT_ID, std::move (l));
 
 4082#if 201103L <= YY_CPLUSPLUS 
 4085      make_CLIENT_ID (location_type l)
 
 4087        return symbol_type (token::TOKEN_CLIENT_ID, std::move (l));
 
 4097#if 201103L <= YY_CPLUSPLUS 
 4100      make_HOSTNAME (location_type l)
 
 4102        return symbol_type (token::TOKEN_HOSTNAME, std::move (l));
 
 4112#if 201103L <= YY_CPLUSPLUS 
 4115      make_FLEX_ID (location_type l)
 
 4117        return symbol_type (token::TOKEN_FLEX_ID, std::move (l));
 
 4127#if 201103L <= YY_CPLUSPLUS 
 4130      make_RELAY (location_type l)
 
 4132        return symbol_type (token::TOKEN_RELAY, std::move (l));
 
 4142#if 201103L <= YY_CPLUSPLUS 
 4145      make_IP_ADDRESSES (location_type l)
 
 4147        return symbol_type (token::TOKEN_IP_ADDRESSES, std::move (l));
 
 4157#if 201103L <= YY_CPLUSPLUS 
 4160      make_HOOKS_LIBRARIES (location_type l)
 
 4162        return symbol_type (token::TOKEN_HOOKS_LIBRARIES, std::move (l));
 
 4172#if 201103L <= YY_CPLUSPLUS 
 4175      make_LIBRARY (location_type l)
 
 4177        return symbol_type (token::TOKEN_LIBRARY, std::move (l));
 
 4187#if 201103L <= YY_CPLUSPLUS 
 4190      make_PARAMETERS (location_type l)
 
 4192        return symbol_type (token::TOKEN_PARAMETERS, std::move (l));
 
 4202#if 201103L <= YY_CPLUSPLUS 
 4205      make_EXPIRED_LEASES_PROCESSING (location_type l)
 
 4207        return symbol_type (token::TOKEN_EXPIRED_LEASES_PROCESSING, std::move (l));
 
 4217#if 201103L <= YY_CPLUSPLUS 
 4220      make_RECLAIM_TIMER_WAIT_TIME (location_type l)
 
 4222        return symbol_type (token::TOKEN_RECLAIM_TIMER_WAIT_TIME, std::move (l));
 
 4232#if 201103L <= YY_CPLUSPLUS 
 4235      make_FLUSH_RECLAIMED_TIMER_WAIT_TIME (location_type l)
 
 4237        return symbol_type (token::TOKEN_FLUSH_RECLAIMED_TIMER_WAIT_TIME, std::move (l));
 
 4247#if 201103L <= YY_CPLUSPLUS 
 4250      make_HOLD_RECLAIMED_TIME (location_type l)
 
 4252        return symbol_type (token::TOKEN_HOLD_RECLAIMED_TIME, std::move (l));
 
 4262#if 201103L <= YY_CPLUSPLUS 
 4265      make_MAX_RECLAIM_LEASES (location_type l)
 
 4267        return symbol_type (token::TOKEN_MAX_RECLAIM_LEASES, std::move (l));
 
 4277#if 201103L <= YY_CPLUSPLUS 
 4280      make_MAX_RECLAIM_TIME (location_type l)
 
 4282        return symbol_type (token::TOKEN_MAX_RECLAIM_TIME, std::move (l));
 
 4292#if 201103L <= YY_CPLUSPLUS 
 4295      make_UNWARNED_RECLAIM_CYCLES (location_type l)
 
 4297        return symbol_type (token::TOKEN_UNWARNED_RECLAIM_CYCLES, std::move (l));
 
 4307#if 201103L <= YY_CPLUSPLUS 
 4310      make_DHCP4O6_PORT (location_type l)
 
 4312        return symbol_type (token::TOKEN_DHCP4O6_PORT, std::move (l));
 
 4322#if 201103L <= YY_CPLUSPLUS 
 4325      make_DHCP_MULTI_THREADING (location_type l)
 
 4327        return symbol_type (token::TOKEN_DHCP_MULTI_THREADING, std::move (l));
 
 4337#if 201103L <= YY_CPLUSPLUS 
 4340      make_ENABLE_MULTI_THREADING (location_type l)
 
 4342        return symbol_type (token::TOKEN_ENABLE_MULTI_THREADING, std::move (l));
 
 4352#if 201103L <= YY_CPLUSPLUS 
 4355      make_THREAD_POOL_SIZE (location_type l)
 
 4357        return symbol_type (token::TOKEN_THREAD_POOL_SIZE, std::move (l));
 
 4367#if 201103L <= YY_CPLUSPLUS 
 4370      make_PACKET_QUEUE_SIZE (location_type l)
 
 4372        return symbol_type (token::TOKEN_PACKET_QUEUE_SIZE, std::move (l));
 
 4382#if 201103L <= YY_CPLUSPLUS 
 4385      make_CONTROL_SOCKET (location_type l)
 
 4387        return symbol_type (token::TOKEN_CONTROL_SOCKET, std::move (l));
 
 4397#if 201103L <= YY_CPLUSPLUS 
 4400      make_CONTROL_SOCKETS (location_type l)
 
 4402        return symbol_type (token::TOKEN_CONTROL_SOCKETS, std::move (l));
 
 4412#if 201103L <= YY_CPLUSPLUS 
 4415      make_SOCKET_TYPE (location_type l)
 
 4417        return symbol_type (token::TOKEN_SOCKET_TYPE, std::move (l));
 
 4427#if 201103L <= YY_CPLUSPLUS 
 4430      make_UNIX (location_type l)
 
 4432        return symbol_type (token::TOKEN_UNIX, std::move (l));
 
 4442#if 201103L <= YY_CPLUSPLUS 
 4445      make_HTTP (location_type l)
 
 4447        return symbol_type (token::TOKEN_HTTP, std::move (l));
 
 4457#if 201103L <= YY_CPLUSPLUS 
 4460      make_HTTPS (location_type l)
 
 4462        return symbol_type (token::TOKEN_HTTPS, std::move (l));
 
 4472#if 201103L <= YY_CPLUSPLUS 
 4475      make_SOCKET_NAME (location_type l)
 
 4477        return symbol_type (token::TOKEN_SOCKET_NAME, std::move (l));
 
 4487#if 201103L <= YY_CPLUSPLUS 
 4490      make_SOCKET_ADDRESS (location_type l)
 
 4492        return symbol_type (token::TOKEN_SOCKET_ADDRESS, std::move (l));
 
 4502#if 201103L <= YY_CPLUSPLUS 
 4505      make_SOCKET_PORT (location_type l)
 
 4507        return symbol_type (token::TOKEN_SOCKET_PORT, std::move (l));
 
 4517#if 201103L <= YY_CPLUSPLUS 
 4520      make_AUTHENTICATION (location_type l)
 
 4522        return symbol_type (token::TOKEN_AUTHENTICATION, std::move (l));
 
 4532#if 201103L <= YY_CPLUSPLUS 
 4535      make_BASIC (location_type l)
 
 4537        return symbol_type (token::TOKEN_BASIC, std::move (l));
 
 4547#if 201103L <= YY_CPLUSPLUS 
 4550      make_REALM (location_type l)
 
 4552        return symbol_type (token::TOKEN_REALM, std::move (l));
 
 4562#if 201103L <= YY_CPLUSPLUS 
 4565      make_DIRECTORY (location_type l)
 
 4567        return symbol_type (token::TOKEN_DIRECTORY, std::move (l));
 
 4577#if 201103L <= YY_CPLUSPLUS 
 4580      make_CLIENTS (location_type l)
 
 4582        return symbol_type (token::TOKEN_CLIENTS, std::move (l));
 
 4592#if 201103L <= YY_CPLUSPLUS 
 4595      make_USER_FILE (location_type l)
 
 4597        return symbol_type (token::TOKEN_USER_FILE, std::move (l));
 
 4607#if 201103L <= YY_CPLUSPLUS 
 4610      make_PASSWORD_FILE (location_type l)
 
 4612        return symbol_type (token::TOKEN_PASSWORD_FILE, std::move (l));
 
 4622#if 201103L <= YY_CPLUSPLUS 
 4625      make_CERT_REQUIRED (location_type l)
 
 4627        return symbol_type (token::TOKEN_CERT_REQUIRED, std::move (l));
 
 4637#if 201103L <= YY_CPLUSPLUS 
 4640      make_HTTP_HEADERS (location_type l)
 
 4642        return symbol_type (token::TOKEN_HTTP_HEADERS, std::move (l));
 
 4652#if 201103L <= YY_CPLUSPLUS 
 4655      make_VALUE (location_type l)
 
 4657        return symbol_type (token::TOKEN_VALUE, std::move (l));
 
 4667#if 201103L <= YY_CPLUSPLUS 
 4670      make_DHCP_QUEUE_CONTROL (location_type l)
 
 4672        return symbol_type (token::TOKEN_DHCP_QUEUE_CONTROL, std::move (l));
 
 4682#if 201103L <= YY_CPLUSPLUS 
 4685      make_ENABLE_QUEUE (location_type l)
 
 4687        return symbol_type (token::TOKEN_ENABLE_QUEUE, std::move (l));
 
 4697#if 201103L <= YY_CPLUSPLUS 
 4700      make_QUEUE_TYPE (location_type l)
 
 4702        return symbol_type (token::TOKEN_QUEUE_TYPE, std::move (l));
 
 4712#if 201103L <= YY_CPLUSPLUS 
 4715      make_CAPACITY (location_type l)
 
 4717        return symbol_type (token::TOKEN_CAPACITY, std::move (l));
 
 4727#if 201103L <= YY_CPLUSPLUS 
 4730      make_DHCP_DDNS (location_type l)
 
 4732        return symbol_type (token::TOKEN_DHCP_DDNS, std::move (l));
 
 4742#if 201103L <= YY_CPLUSPLUS 
 4745      make_ENABLE_UPDATES (location_type l)
 
 4747        return symbol_type (token::TOKEN_ENABLE_UPDATES, std::move (l));
 
 4757#if 201103L <= YY_CPLUSPLUS 
 4760      make_SERVER_IP (location_type l)
 
 4762        return symbol_type (token::TOKEN_SERVER_IP, std::move (l));
 
 4772#if 201103L <= YY_CPLUSPLUS 
 4775      make_SERVER_PORT (location_type l)
 
 4777        return symbol_type (token::TOKEN_SERVER_PORT, std::move (l));
 
 4787#if 201103L <= YY_CPLUSPLUS 
 4790      make_SENDER_IP (location_type l)
 
 4792        return symbol_type (token::TOKEN_SENDER_IP, std::move (l));
 
 4802#if 201103L <= YY_CPLUSPLUS 
 4805      make_SENDER_PORT (location_type l)
 
 4807        return symbol_type (token::TOKEN_SENDER_PORT, std::move (l));
 
 4817#if 201103L <= YY_CPLUSPLUS 
 4820      make_MAX_QUEUE_SIZE (location_type l)
 
 4822        return symbol_type (token::TOKEN_MAX_QUEUE_SIZE, std::move (l));
 
 4832#if 201103L <= YY_CPLUSPLUS 
 4835      make_NCR_PROTOCOL (location_type l)
 
 4837        return symbol_type (token::TOKEN_NCR_PROTOCOL, std::move (l));
 
 4847#if 201103L <= YY_CPLUSPLUS 
 4850      make_NCR_FORMAT (location_type l)
 
 4852        return symbol_type (token::TOKEN_NCR_FORMAT, std::move (l));
 
 4862#if 201103L <= YY_CPLUSPLUS 
 4865      make_TCP (location_type l)
 
 4867        return symbol_type (token::TOKEN_TCP, std::move (l));
 
 4877#if 201103L <= YY_CPLUSPLUS 
 4880      make_JSON (location_type l)
 
 4882        return symbol_type (token::TOKEN_JSON, std::move (l));
 
 4892#if 201103L <= YY_CPLUSPLUS 
 4895      make_WHEN_PRESENT (location_type l)
 
 4897        return symbol_type (token::TOKEN_WHEN_PRESENT, std::move (l));
 
 4907#if 201103L <= YY_CPLUSPLUS 
 4910      make_NEVER (location_type l)
 
 4912        return symbol_type (token::TOKEN_NEVER, std::move (l));
 
 4922#if 201103L <= YY_CPLUSPLUS 
 4925      make_ALWAYS (location_type l)
 
 4927        return symbol_type (token::TOKEN_ALWAYS, std::move (l));
 
 4937#if 201103L <= YY_CPLUSPLUS 
 4940      make_WHEN_NOT_PRESENT (location_type l)
 
 4942        return symbol_type (token::TOKEN_WHEN_NOT_PRESENT, std::move (l));
 
 4952#if 201103L <= YY_CPLUSPLUS 
 4955      make_HOSTNAME_CHAR_SET (location_type l)
 
 4957        return symbol_type (token::TOKEN_HOSTNAME_CHAR_SET, std::move (l));
 
 4967#if 201103L <= YY_CPLUSPLUS 
 4970      make_HOSTNAME_CHAR_REPLACEMENT (location_type l)
 
 4972        return symbol_type (token::TOKEN_HOSTNAME_CHAR_REPLACEMENT, std::move (l));
 
 4982#if 201103L <= YY_CPLUSPLUS 
 4985      make_EARLY_GLOBAL_RESERVATIONS_LOOKUP (location_type l)
 
 4987        return symbol_type (token::TOKEN_EARLY_GLOBAL_RESERVATIONS_LOOKUP, std::move (l));
 
 4997#if 201103L <= YY_CPLUSPLUS 
 5000      make_IP_RESERVATIONS_UNIQUE (location_type l)
 
 5002        return symbol_type (token::TOKEN_IP_RESERVATIONS_UNIQUE, std::move (l));
 
 5012#if 201103L <= YY_CPLUSPLUS 
 5015      make_RESERVATIONS_LOOKUP_FIRST (location_type l)
 
 5017        return symbol_type (token::TOKEN_RESERVATIONS_LOOKUP_FIRST, std::move (l));
 
 5027#if 201103L <= YY_CPLUSPLUS 
 5030      make_LOGGERS (location_type l)
 
 5032        return symbol_type (token::TOKEN_LOGGERS, std::move (l));
 
 5042#if 201103L <= YY_CPLUSPLUS 
 5045      make_OUTPUT_OPTIONS (location_type l)
 
 5047        return symbol_type (token::TOKEN_OUTPUT_OPTIONS, std::move (l));
 
 5057#if 201103L <= YY_CPLUSPLUS 
 5060      make_OUTPUT (location_type l)
 
 5062        return symbol_type (token::TOKEN_OUTPUT, std::move (l));
 
 5072#if 201103L <= YY_CPLUSPLUS 
 5075      make_DEBUGLEVEL (location_type l)
 
 5077        return symbol_type (token::TOKEN_DEBUGLEVEL, std::move (l));
 
 5087#if 201103L <= YY_CPLUSPLUS 
 5090      make_SEVERITY (location_type l)
 
 5092        return symbol_type (token::TOKEN_SEVERITY, std::move (l));
 
 5102#if 201103L <= YY_CPLUSPLUS 
 5105      make_FLUSH (location_type l)
 
 5107        return symbol_type (token::TOKEN_FLUSH, std::move (l));
 
 5117#if 201103L <= YY_CPLUSPLUS 
 5120      make_MAXSIZE (location_type l)
 
 5122        return symbol_type (token::TOKEN_MAXSIZE, std::move (l));
 
 5132#if 201103L <= YY_CPLUSPLUS 
 5135      make_MAXVER (location_type l)
 
 5137        return symbol_type (token::TOKEN_MAXVER, std::move (l));
 
 5147#if 201103L <= YY_CPLUSPLUS 
 5150      make_PATTERN (location_type l)
 
 5152        return symbol_type (token::TOKEN_PATTERN, std::move (l));
 
 5162#if 201103L <= YY_CPLUSPLUS 
 5165      make_COMPATIBILITY (location_type l)
 
 5167        return symbol_type (token::TOKEN_COMPATIBILITY, std::move (l));
 
 5177#if 201103L <= YY_CPLUSPLUS 
 5180      make_LENIENT_OPTION_PARSING (location_type l)
 
 5182        return symbol_type (token::TOKEN_LENIENT_OPTION_PARSING, std::move (l));
 
 5192#if 201103L <= YY_CPLUSPLUS 
 5195      make_IGNORE_DHCP_SERVER_ID (location_type l)
 
 5197        return symbol_type (token::TOKEN_IGNORE_DHCP_SERVER_ID, std::move (l));
 
 5207#if 201103L <= YY_CPLUSPLUS 
 5210      make_IGNORE_RAI_LINK_SEL (location_type l)
 
 5212        return symbol_type (token::TOKEN_IGNORE_RAI_LINK_SEL, std::move (l));
 
 5222#if 201103L <= YY_CPLUSPLUS 
 5225      make_EXCLUDE_FIRST_LAST_24 (location_type l)
 
 5227        return symbol_type (token::TOKEN_EXCLUDE_FIRST_LAST_24, std::move (l));
 
 5237#if 201103L <= YY_CPLUSPLUS 
 5240      make_TOPLEVEL_JSON (location_type l)
 
 5242        return symbol_type (token::TOKEN_TOPLEVEL_JSON, std::move (l));
 
 5252#if 201103L <= YY_CPLUSPLUS 
 5255      make_TOPLEVEL_DHCP4 (location_type l)
 
 5257        return symbol_type (token::TOKEN_TOPLEVEL_DHCP4, std::move (l));
 
 5267#if 201103L <= YY_CPLUSPLUS 
 5270      make_SUB_DHCP4 (location_type l)
 
 5272        return symbol_type (token::TOKEN_SUB_DHCP4, std::move (l));
 
 5282#if 201103L <= YY_CPLUSPLUS 
 5285      make_SUB_INTERFACES4 (location_type l)
 
 5287        return symbol_type (token::TOKEN_SUB_INTERFACES4, std::move (l));
 
 5297#if 201103L <= YY_CPLUSPLUS 
 5300      make_SUB_SUBNET4 (location_type l)
 
 5302        return symbol_type (token::TOKEN_SUB_SUBNET4, std::move (l));
 
 5312#if 201103L <= YY_CPLUSPLUS 
 5315      make_SUB_POOL4 (location_type l)
 
 5317        return symbol_type (token::TOKEN_SUB_POOL4, std::move (l));
 
 5327#if 201103L <= YY_CPLUSPLUS 
 5330      make_SUB_RESERVATION (location_type l)
 
 5332        return symbol_type (token::TOKEN_SUB_RESERVATION, std::move (l));
 
 5342#if 201103L <= YY_CPLUSPLUS 
 5345      make_SUB_OPTION_DEFS (location_type l)
 
 5347        return symbol_type (token::TOKEN_SUB_OPTION_DEFS, std::move (l));
 
 5357#if 201103L <= YY_CPLUSPLUS 
 5360      make_SUB_OPTION_DEF (location_type l)
 
 5362        return symbol_type (token::TOKEN_SUB_OPTION_DEF, std::move (l));
 
 5372#if 201103L <= YY_CPLUSPLUS 
 5375      make_SUB_OPTION_DATA (location_type l)
 
 5377        return symbol_type (token::TOKEN_SUB_OPTION_DATA, std::move (l));
 
 5387#if 201103L <= YY_CPLUSPLUS 
 5390      make_SUB_HOOKS_LIBRARY (location_type l)
 
 5392        return symbol_type (token::TOKEN_SUB_HOOKS_LIBRARY, std::move (l));
 
 5402#if 201103L <= YY_CPLUSPLUS 
 5405      make_SUB_DHCP_DDNS (location_type l)
 
 5407        return symbol_type (token::TOKEN_SUB_DHCP_DDNS, std::move (l));
 
 5417#if 201103L <= YY_CPLUSPLUS 
 5420      make_SUB_CONFIG_CONTROL (location_type l)
 
 5422        return symbol_type (token::TOKEN_SUB_CONFIG_CONTROL, std::move (l));
 
 5432#if 201103L <= YY_CPLUSPLUS 
 5435      make_STRING (std::string v, location_type l)
 
 5437        return symbol_type (token::TOKEN_STRING, std::move (v), std::move (l));
 
 5447#if 201103L <= YY_CPLUSPLUS 
 5450      make_INTEGER (int64_t v, location_type l)
 
 5452        return symbol_type (token::TOKEN_INTEGER, std::move (v), std::move (l));
 
 5462#if 201103L <= YY_CPLUSPLUS 
 5465      make_FLOAT (
double v, location_type l)
 
 5467        return symbol_type (token::TOKEN_FLOAT, std::move (v), std::move (l));
 
 5477#if 201103L <= YY_CPLUSPLUS 
 5480      make_BOOLEAN (
bool v, location_type l)
 
 5482        return symbol_type (token::TOKEN_BOOLEAN, std::move (v), std::move (l));
 
 5513#if YY_CPLUSPLUS < 201103L 
 5522    typedef short state_type;
 
 5525    int yy_syntax_error_arguments_ (
const context& yyctx,
 
 5526                                    symbol_kind_type yyarg[], 
int yyargn) 
const;
 
 5530    virtual std::string yysyntax_error_ (
const context& yyctx) 
const;
 
 5534    static state_type yy_lr_goto_state_ (state_type yystate, 
int yysym);
 
 5538    static bool yy_pact_value_is_default_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5542    static bool yy_table_value_is_error_ (
int yyvalue) 
YY_NOEXCEPT;
 
 5544    static const short yypact_ninf_;
 
 5545    static const signed char yytable_ninf_;
 
 5550    static symbol_kind_type yytranslate_ (
int t) 
YY_NOEXCEPT;
 
 5553    static std::string yytnamerr_ (
const char *yystr);
 
 5556    static const char* 
const yytname_[];
 
 5562    static const short yypact_[];
 
 5567    static const short yydefact_[];
 
 5570    static const short yypgoto_[];
 
 5573    static const short yydefgoto_[];
 
 5578    static const short yytable_[];
 
 5580    static const short yycheck_[];
 
 5584    static const short yystos_[];
 
 5587    static const short yyr1_[];
 
 5590    static const signed char yyr2_[];
 
 5595    static const short yyrline_[];
 
 5597    virtual void yy_reduce_print_ (
int r) 
const;
 
 5599    virtual void yy_stack_print_ () 
const;
 
 5604    std::ostream* yycdebug_;
 
 5609    template <
typename Base>
 
 5610    void yy_print_ (std::ostream& yyo, 
const basic_symbol<Base>& yysym) 
const;
 
 5617    template <
typename Base>
 
 5618    void yy_destroy_ (
const char* yymsg, basic_symbol<Base>& yysym) 
const;
 
 5628      typedef state_type kind_type;
 
 5640      void move (by_state& that);
 
 5648      enum { empty_state = 0 };
 
 5656    struct stack_symbol_type : basic_symbol<by_state>
 
 5659      typedef basic_symbol<by_state> super_type;
 
 5661      stack_symbol_type ();
 
 5663      stack_symbol_type (
YY_RVREF (stack_symbol_type) that);
 
 5665      stack_symbol_type (state_type s, 
YY_MOVE_REF (symbol_type) sym);
 
 5666#if YY_CPLUSPLUS < 201103L 
 5669      stack_symbol_type& operator= (stack_symbol_type& that);
 
 5673      stack_symbol_type& operator= (
const stack_symbol_type& that);
 
 5678    template <
typename T, 
typename S = std::vector<T> >
 
 5683      typedef typename S::iterator iterator;
 
 5684      typedef typename S::const_iterator const_iterator;
 
 5685      typedef typename S::size_type size_type;
 
 5686      typedef typename std::ptrdiff_t index_type;
 
 5692#if 201103L <= YY_CPLUSPLUS 
 5694      stack (
const stack&) = 
delete;
 
 5696      stack& operator= (
const stack&) = 
delete;
 
 5703      operator[] (index_type i)
 const 
 5705        return seq_[size_type (size () - 1 - i)];
 
 5712      operator[] (index_type i)
 
 5714        return seq_[size_type (size () - 1 - i)];
 
 5723        seq_.push_back (T ());
 
 5724        operator[] (0).move (t);
 
 5746        return index_type (seq_.size ());
 
 5753        return seq_.begin ();
 
 5773        operator[] (index_type i)
 const 
 5775          return stack_[range_ - i];
 
 
 5779        const stack& stack_;
 
 
 5784#if YY_CPLUSPLUS < 201103L 
 5786      stack (
const stack&);
 
 5788      stack& operator= (
const stack&);
 
 5796    typedef stack<stack_symbol_type> stack_type;
 
 5799    stack_type yystack_;
 
 5806    void yypush_ (
const char* m, 
YY_MOVE_REF (stack_symbol_type) sym);
 
 5814    void yypush_ (
const char* m, state_type s, 
YY_MOVE_REF (symbol_type) sym);