Adding upstream version 2.2.0.upstream/2.2.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 6359 insertions, 0 deletions

diff --git a/src/bin/dhcp6/dhcp6_parser.cc b/src/bin/dhcp6/dhcp6_parser.cc
new file mode 100644
index 0000000..07b11ee
--- /dev/null
+++ b/src/bin/dhcp6/dhcp6_parser.cc
@@ -0,0 +1,6359 @@
+// A Bison parser, made by GNU Bison 3.8.2.
+
+// Skeleton implementation for Bison LALR(1) parsers in C++
+
+// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// As a special exception, you may create a larger work that contains
+// part or all of the Bison parser skeleton and distribute that work
+// under terms of your choice, so long as that work isn't itself a
+// parser generator using the skeleton or a modified version thereof
+// as a parser skeleton.  Alternatively, if you modify or redistribute
+// the parser skeleton itself, you may (at your option) remove this
+// special exception, which will cause the skeleton and the resulting
+// Bison output files to be licensed under the GNU General Public
+// License without this special exception.
+
+// This special exception was added by the Free Software Foundation in
+// version 2.2 of Bison.
+
+// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+// especially those whose name start with YY_ or yy_.  They are
+// private implementation details that can be changed or removed.
+
+
+// Take the name prefix into account.
+#define yylex   parser6_lex
+
+
+
+#include "dhcp6_parser.h"
+
+
+// Unqualified %code blocks.
+#line 34 "dhcp6_parser.yy"
+
+#include <dhcp6/parser_context.h>
+
+#line 52 "dhcp6_parser.cc"
+
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> // FIXME: INFRINGES ON USER NAME SPACE.
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+
+// Whether we are compiled with exception support.
+#ifndef YY_EXCEPTIONS
+# if defined __GNUC__ && !defined __EXCEPTIONS
+#  define YY_EXCEPTIONS 0
+# else
+#  define YY_EXCEPTIONS 1
+# endif
+#endif
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K].location)
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+# ifndef YYLLOC_DEFAULT
+#  define YYLLOC_DEFAULT(Current, Rhs, N)                               \
+    do                                                                  \
+      if (N)                                                            \
+        {                                                               \
+          (Current).begin  = YYRHSLOC (Rhs, 1).begin;                   \
+          (Current).end    = YYRHSLOC (Rhs, N).end;                     \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end;      \
+        }                                                               \
+    while (false)
+# endif
+
+
+// Enable debugging if requested.
+#if PARSER6_DEBUG
+
+// A pseudo ostream that takes yydebug_ into account.
+# define YYCDEBUG if (yydebug_) (*yycdebug_)
+
+# define YY_SYMBOL_PRINT(Title, Symbol)         \
+  do {                                          \
+    if (yydebug_)                               \
+    {                                           \
+      *yycdebug_ << Title << ' ';               \
+      yy_print_ (*yycdebug_, Symbol);           \
+      *yycdebug_ << '\n';                       \
+    }                                           \
+  } while (false)
+
+# define YY_REDUCE_PRINT(Rule)          \
+  do {                                  \
+    if (yydebug_)                       \
+      yy_reduce_print_ (Rule);          \
+  } while (false)
+
+# define YY_STACK_PRINT()               \
+  do {                                  \
+    if (yydebug_)                       \
+      yy_stack_print_ ();                \
+  } while (false)
+
+#else // !PARSER6_DEBUG
+
+# define YYCDEBUG if (false) std::cerr
+# define YY_SYMBOL_PRINT(Title, Symbol)  YY_USE (Symbol)
+# define YY_REDUCE_PRINT(Rule)           static_cast<void> (0)
+# define YY_STACK_PRINT()                static_cast<void> (0)
+
+#endif // !PARSER6_DEBUG
+
+#define yyerrok         (yyerrstatus_ = 0)
+#define yyclearin       (yyla.clear ())
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+#define YYRECOVERING()  (!!yyerrstatus_)
+
+#line 14 "dhcp6_parser.yy"
+namespace isc { namespace dhcp {
+#line 145 "dhcp6_parser.cc"
+
+  /// Build a parser object.
+  Dhcp6Parser::Dhcp6Parser (isc::dhcp::Parser6Context& ctx_yyarg)
+#if PARSER6_DEBUG
+    : yydebug_ (false),
+      yycdebug_ (&std::cerr),
+#else
+    :
+#endif
+      ctx (ctx_yyarg)
+  {}
+
+  Dhcp6Parser::~Dhcp6Parser ()
+  {}
+
+  Dhcp6Parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW
+  {}
+
+  /*---------.
+  | symbol.  |
+  `---------*/
+
+
+
+  // by_state.
+  Dhcp6Parser::by_state::by_state () YY_NOEXCEPT
+    : state (empty_state)
+  {}
+
+  Dhcp6Parser::by_state::by_state (const by_state& that) YY_NOEXCEPT
+    : state (that.state)
+  {}
+
+  void
+  Dhcp6Parser::by_state::clear () YY_NOEXCEPT
+  {
+    state = empty_state;
+  }
+
+  void
+  Dhcp6Parser::by_state::move (by_state& that)
+  {
+    state = that.state;
+    that.clear ();
+  }
+
+  Dhcp6Parser::by_state::by_state (state_type s) YY_NOEXCEPT
+    : state (s)
+  {}
+
+  Dhcp6Parser::symbol_kind_type
+  Dhcp6Parser::by_state::kind () const YY_NOEXCEPT
+  {
+    if (state == empty_state)
+      return symbol_kind::S_YYEMPTY;
+    else
+      return YY_CAST (symbol_kind_type, yystos_[+state]);
+  }
+
+  Dhcp6Parser::stack_symbol_type::stack_symbol_type ()
+  {}
+
+  Dhcp6Parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that)
+    : super_type (YY_MOVE (that.state), YY_MOVE (that.location))
+  {
+    switch (that.kind ())
+    {
+      case symbol_kind::S_value: // value
+      case symbol_kind::S_map_value: // map_value
+      case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
+      case symbol_kind::S_db_type: // db_type
+      case symbol_kind::S_on_fail_mode: // on_fail_mode
+      case symbol_kind::S_hr_mode: // hr_mode
+      case symbol_kind::S_duid_type: // duid_type
+      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
+        value.YY_MOVE_OR_COPY< ElementPtr > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_BOOLEAN: // "boolean"
+        value.YY_MOVE_OR_COPY< bool > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_FLOAT: // "floating point"
+        value.YY_MOVE_OR_COPY< double > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_INTEGER: // "integer"
+        value.YY_MOVE_OR_COPY< int64_t > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_STRING: // "constant string"
+        value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value));
+        break;
+
+      default:
+        break;
+    }
+
+#if 201103L <= YY_CPLUSPLUS
+    // that is emptied.
+    that.state = empty_state;
+#endif
+  }
+
+  Dhcp6Parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that)
+    : super_type (s, YY_MOVE (that.location))
+  {
+    switch (that.kind ())
+    {
+      case symbol_kind::S_value: // value
+      case symbol_kind::S_map_value: // map_value
+      case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
+      case symbol_kind::S_db_type: // db_type
+      case symbol_kind::S_on_fail_mode: // on_fail_mode
+      case symbol_kind::S_hr_mode: // hr_mode
+      case symbol_kind::S_duid_type: // duid_type
+      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
+        value.move< ElementPtr > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_BOOLEAN: // "boolean"
+        value.move< bool > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_FLOAT: // "floating point"
+        value.move< double > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_INTEGER: // "integer"
+        value.move< int64_t > (YY_MOVE (that.value));
+        break;
+
+      case symbol_kind::S_STRING: // "constant string"
+        value.move< std::string > (YY_MOVE (that.value));
+        break;
+
+      default:
+        break;
+    }
+
+    // that is emptied.
+    that.kind_ = symbol_kind::S_YYEMPTY;
+  }
+
+#if YY_CPLUSPLUS < 201103L
+  Dhcp6Parser::stack_symbol_type&
+  Dhcp6Parser::stack_symbol_type::operator= (const stack_symbol_type& that)
+  {
+    state = that.state;
+    switch (that.kind ())
+    {
+      case symbol_kind::S_value: // value
+      case symbol_kind::S_map_value: // map_value
+      case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
+      case symbol_kind::S_db_type: // db_type
+      case symbol_kind::S_on_fail_mode: // on_fail_mode
+      case symbol_kind::S_hr_mode: // hr_mode
+      case symbol_kind::S_duid_type: // duid_type
+      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
+        value.copy< ElementPtr > (that.value);
+        break;
+
+      case symbol_kind::S_BOOLEAN: // "boolean"
+        value.copy< bool > (that.value);
+        break;
+
+      case symbol_kind::S_FLOAT: // "floating point"
+        value.copy< double > (that.value);
+        break;
+
+      case symbol_kind::S_INTEGER: // "integer"
+        value.copy< int64_t > (that.value);
+        break;
+
+      case symbol_kind::S_STRING: // "constant string"
+        value.copy< std::string > (that.value);
+        break;
+
+      default:
+        break;
+    }
+
+    location = that.location;
+    return *this;
+  }
+
+  Dhcp6Parser::stack_symbol_type&
+  Dhcp6Parser::stack_symbol_type::operator= (stack_symbol_type& that)
+  {
+    state = that.state;
+    switch (that.kind ())
+    {
+      case symbol_kind::S_value: // value
+      case symbol_kind::S_map_value: // map_value
+      case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
+      case symbol_kind::S_db_type: // db_type
+      case symbol_kind::S_on_fail_mode: // on_fail_mode
+      case symbol_kind::S_hr_mode: // hr_mode
+      case symbol_kind::S_duid_type: // duid_type
+      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
+        value.move< ElementPtr > (that.value);
+        break;
+
+      case symbol_kind::S_BOOLEAN: // "boolean"
+        value.move< bool > (that.value);
+        break;
+
+      case symbol_kind::S_FLOAT: // "floating point"
+        value.move< double > (that.value);
+        break;
+
+      case symbol_kind::S_INTEGER: // "integer"
+        value.move< int64_t > (that.value);
+        break;
+
+      case symbol_kind::S_STRING: // "constant string"
+        value.move< std::string > (that.value);
+        break;
+
+      default:
+        break;
+    }
+
+    location = that.location;
+    // that is emptied.
+    that.state = empty_state;
+    return *this;
+  }
+#endif
+
+  template <typename Base>
+  void
+  Dhcp6Parser::yy_destroy_ (const char* yymsg, basic_symbol<Base>& yysym) const
+  {
+    if (yymsg)
+      YY_SYMBOL_PRINT (yymsg, yysym);
+  }
+
+#if PARSER6_DEBUG
+  template <typename Base>
+  void
+  Dhcp6Parser::yy_print_ (std::ostream& yyo, const basic_symbol<Base>& yysym) const
+  {
+    std::ostream& yyoutput = yyo;
+    YY_USE (yyoutput);
+    if (yysym.empty ())
+      yyo << "empty symbol";
+    else
+      {
+        symbol_kind_type yykind = yysym.kind ();
+        yyo << (yykind < YYNTOKENS ? "token" : "nterm")
+            << ' ' << yysym.name () << " ("
+            << yysym.location << ": ";
+        switch (yykind)
+    {
+      case symbol_kind::S_STRING: // "constant string"
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < std::string > (); }
+#line 404 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_INTEGER: // "integer"
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < int64_t > (); }
+#line 410 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_FLOAT: // "floating point"
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < double > (); }
+#line 416 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_BOOLEAN: // "boolean"
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < bool > (); }
+#line 422 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_value: // value
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 428 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_map_value: // map_value
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 434 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 440 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_db_type: // db_type
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 446 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_on_fail_mode: // on_fail_mode
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 452 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_hr_mode: // hr_mode
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 458 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_duid_type: // duid_type
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 464 "dhcp6_parser.cc"
+        break;
+
+      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
+#line 293 "dhcp6_parser.yy"
+                 { yyoutput << yysym.value.template as < ElementPtr > (); }
+#line 470 "dhcp6_parser.cc"
+        break;
+
+      default:
+        break;
+    }
+        yyo << ')';
+      }
+  }
+#endif
+
+  void
+  Dhcp6Parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym)
+  {
+    if (m)
+      YY_SYMBOL_PRINT (m, sym);
+    yystack_.push (YY_MOVE (sym));
+  }
+
+  void
+  Dhcp6Parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym)
+  {
+#if 201103L <= YY_CPLUSPLUS
+    yypush_ (m, stack_symbol_type (s, std::move (sym)));
+#else
+    stack_symbol_type ss (s, sym);
+    yypush_ (m, ss);
+#endif
+  }
+
+  void
+  Dhcp6Parser::yypop_ (int n) YY_NOEXCEPT
+  {
+    yystack_.pop (n);
+  }
+
+#if PARSER6_DEBUG
+  std::ostream&
+  Dhcp6Parser::debug_stream () const
+  {
+    return *yycdebug_;
+  }
+
+  void
+  Dhcp6Parser::set_debug_stream (std::ostream& o)
+  {
+    yycdebug_ = &o;
+  }
+
+
+  Dhcp6Parser::debug_level_type
+  Dhcp6Parser::debug_level () const
+  {
+    return yydebug_;
+  }
+
+  void
+  Dhcp6Parser::set_debug_level (debug_level_type l)
+  {
+    yydebug_ = l;
+  }
+#endif // PARSER6_DEBUG
+
+  Dhcp6Parser::state_type
+  Dhcp6Parser::yy_lr_goto_state_ (state_type yystate, int yysym)
+  {
+    int yyr = yypgoto_[yysym - YYNTOKENS] + yystate;
+    if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
+      return yytable_[yyr];
+    else
+      return yydefgoto_[yysym - YYNTOKENS];
+  }
+
+  bool
+  Dhcp6Parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT
+  {
+    return yyvalue == yypact_ninf_;
+  }
+
+  bool
+  Dhcp6Parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT
+  {
+    return yyvalue == yytable_ninf_;
+  }
+
+  int
+  Dhcp6Parser::operator() ()
+  {
+    return parse ();
+  }
+
+  int
+  Dhcp6Parser::parse ()
+  {
+    int yyn;
+    /// Length of the RHS of the rule being reduced.
+    int yylen = 0;
+
+    // Error handling.
+    int yynerrs_ = 0;
+    int yyerrstatus_ = 0;
+
+    /// The lookahead symbol.
+    symbol_type yyla;
+
+    /// The locations where the error started and ended.
+    stack_symbol_type yyerror_range[3];
+
+    /// The return value of parse ().
+    int yyresult;
+
+#if YY_EXCEPTIONS
+    try
+#endif // YY_EXCEPTIONS
+      {
+    YYCDEBUG << "Starting parse\n";
+
+
+    /* Initialize the stack.  The initial state will be set in
+       yynewstate, since the latter expects the semantical and the
+       location values to have been already stored, initialize these
+       stacks with a primary value.  */
+    yystack_.clear ();
+    yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla));
+
+  /*-----------------------------------------------.
+  | yynewstate -- push a new symbol on the stack.  |
+  `-----------------------------------------------*/
+  yynewstate:
+    YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n';
+    YY_STACK_PRINT ();
+
+    // Accept?
+    if (yystack_[0].state == yyfinal_)
+      YYACCEPT;
+
+    goto yybackup;
+
+
+  /*-----------.
+  | yybackup.  |
+  `-----------*/
+  yybackup:
+    // Try to take a decision without lookahead.
+    yyn = yypact_[+yystack_[0].state];
+    if (yy_pact_value_is_default_ (yyn))
+      goto yydefault;
+
+    // Read a lookahead token.
+    if (yyla.empty ())
+      {
+        YYCDEBUG << "Reading a token\n";
+#if YY_EXCEPTIONS
+        try
+#endif // YY_EXCEPTIONS
+          {
+            symbol_type yylookahead (yylex (ctx));
+            yyla.move (yylookahead);
+          }
+#if YY_EXCEPTIONS
+        catch (const syntax_error& yyexc)
+          {
+            YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
+            error (yyexc);
+            goto yyerrlab1;
+          }
+#endif // YY_EXCEPTIONS
+      }
+    YY_SYMBOL_PRINT ("Next token is", yyla);
+
+    if (yyla.kind () == symbol_kind::S_YYerror)
+    {
+      // The scanner already issued an error message, process directly
+      // to error recovery.  But do not keep the error token as
+      // lookahead, it is too special and may lead us to an endless
+      // loop in error recovery. */
+      yyla.kind_ = symbol_kind::S_YYUNDEF;
+      goto yyerrlab1;
+    }
+
+    /* If the proper action on seeing token YYLA.TYPE is to reduce or
+       to detect an error, take that action.  */
+    yyn += yyla.kind ();
+    if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ())
+      {
+        goto yydefault;
+      }
+
+    // Reduce or error.
+    yyn = yytable_[yyn];
+    if (yyn <= 0)
+      {
+        if (yy_table_value_is_error_ (yyn))
+          goto yyerrlab;
+        yyn = -yyn;
+        goto yyreduce;
+      }
+
+    // Count tokens shifted since error; after three, turn off error status.
+    if (yyerrstatus_)
+      --yyerrstatus_;
+
+    // Shift the lookahead token.
+    yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla));
+    goto yynewstate;
+
+
+  /*-----------------------------------------------------------.
+  | yydefault -- do the default action for the current state.  |
+  `-----------------------------------------------------------*/
+  yydefault:
+    yyn = yydefact_[+yystack_[0].state];
+    if (yyn == 0)
+      goto yyerrlab;
+    goto yyreduce;
+
+
+  /*-----------------------------.
+  | yyreduce -- do a reduction.  |
+  `-----------------------------*/
+  yyreduce:
+    yylen = yyr2_[yyn];
+    {
+      stack_symbol_type yylhs;
+      yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]);
+      /* Variants are always initialized to an empty instance of the
+         correct type. The default '$$ = $1' action is NOT applied
+         when using variants.  */
+      switch (yyr1_[yyn])
+    {
+      case symbol_kind::S_value: // value
+      case symbol_kind::S_map_value: // map_value
+      case symbol_kind::S_ddns_replace_client_name_value: // ddns_replace_client_name_value
+      case symbol_kind::S_db_type: // db_type
+      case symbol_kind::S_on_fail_mode: // on_fail_mode
+      case symbol_kind::S_hr_mode: // hr_mode
+      case symbol_kind::S_duid_type: // duid_type
+      case symbol_kind::S_ncr_protocol_value: // ncr_protocol_value
+        yylhs.value.emplace< ElementPtr > ();
+        break;
+
+      case symbol_kind::S_BOOLEAN: // "boolean"
+        yylhs.value.emplace< bool > ();
+        break;
+
+      case symbol_kind::S_FLOAT: // "floating point"
+        yylhs.value.emplace< double > ();
+        break;
+
+      case symbol_kind::S_INTEGER: // "integer"
+        yylhs.value.emplace< int64_t > ();
+        break;
+
+      case symbol_kind::S_STRING: // "constant string"
+        yylhs.value.emplace< std::string > ();
+        break;
+
+      default:
+        break;
+    }
+
+
+      // Default location.
+      {
+        stack_type::slice range (yystack_, yylen);
+        YYLLOC_DEFAULT (yylhs.location, range, yylen);
+        yyerror_range[1].location = yylhs.location;
+      }
+
+      // Perform the reduction.
+      YY_REDUCE_PRINT (yyn);
+#if YY_EXCEPTIONS
+      try
+#endif // YY_EXCEPTIONS
+        {
+          switch (yyn)
+            {
+  case 2: // $@1: %empty
+#line 302 "dhcp6_parser.yy"
+                     { ctx.ctx_ = ctx.NO_KEYWORD; }
+#line 750 "dhcp6_parser.cc"
+    break;
+
+  case 4: // $@2: %empty
+#line 303 "dhcp6_parser.yy"
+                      { ctx.ctx_ = ctx.CONFIG; }
+#line 756 "dhcp6_parser.cc"
+    break;
+
+  case 6: // $@3: %empty
+#line 304 "dhcp6_parser.yy"
+                 { ctx.ctx_ = ctx.DHCP6; }
+#line 762 "dhcp6_parser.cc"
+    break;
+
+  case 8: // $@4: %empty
+#line 305 "dhcp6_parser.yy"
+                       { ctx.ctx_ = ctx.INTERFACES_CONFIG; }
+#line 768 "dhcp6_parser.cc"
+    break;
+
+  case 10: // $@5: %empty
+#line 306 "dhcp6_parser.yy"
+                   { ctx.ctx_ = ctx.SUBNET6; }
+#line 774 "dhcp6_parser.cc"
+    break;
+
+  case 12: // $@6: %empty
+#line 307 "dhcp6_parser.yy"
+                 { ctx.ctx_ = ctx.POOLS; }
+#line 780 "dhcp6_parser.cc"
+    break;
+
+  case 14: // $@7: %empty
+#line 308 "dhcp6_parser.yy"
+                   { ctx.ctx_ = ctx.PD_POOLS; }
+#line 786 "dhcp6_parser.cc"
+    break;
+
+  case 16: // $@8: %empty
+#line 309 "dhcp6_parser.yy"
+                       { ctx.ctx_ = ctx.RESERVATIONS; }
+#line 792 "dhcp6_parser.cc"
+    break;
+
+  case 18: // $@9: %empty
+#line 310 "dhcp6_parser.yy"
+                       { ctx.ctx_ = ctx.DHCP6; }
+#line 798 "dhcp6_parser.cc"
+    break;
+
+  case 20: // $@10: %empty
+#line 311 "dhcp6_parser.yy"
+                      { ctx.ctx_ = ctx.OPTION_DEF; }
+#line 804 "dhcp6_parser.cc"
+    break;
+
+  case 22: // $@11: %empty
+#line 312 "dhcp6_parser.yy"
+                       { ctx.ctx_ = ctx.OPTION_DATA; }
+#line 810 "dhcp6_parser.cc"
+    break;
+
+  case 24: // $@12: %empty
+#line 313 "dhcp6_parser.yy"
+                         { ctx.ctx_ = ctx.HOOKS_LIBRARIES; }
+#line 816 "dhcp6_parser.cc"
+    break;
+
+  case 26: // $@13: %empty
+#line 314 "dhcp6_parser.yy"
+                     { ctx.ctx_ = ctx.DHCP_DDNS; }
+#line 822 "dhcp6_parser.cc"
+    break;
+
+  case 28: // $@14: %empty
+#line 315 "dhcp6_parser.yy"
+                          { ctx.ctx_ = ctx.CONFIG_CONTROL; }
+#line 828 "dhcp6_parser.cc"
+    break;
+
+  case 30: // value: "integer"
+#line 323 "dhcp6_parser.yy"
+               { yylhs.value.as < ElementPtr > () = ElementPtr(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location))); }
+#line 834 "dhcp6_parser.cc"
+    break;
+
+  case 31: // value: "floating point"
+#line 324 "dhcp6_parser.yy"
+             { yylhs.value.as < ElementPtr > () = ElementPtr(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location))); }
+#line 840 "dhcp6_parser.cc"
+    break;
+
+  case 32: // value: "boolean"
+#line 325 "dhcp6_parser.yy"
+               { yylhs.value.as < ElementPtr > () = ElementPtr(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location))); }
+#line 846 "dhcp6_parser.cc"
+    break;
+
+  case 33: // value: "constant string"
+#line 326 "dhcp6_parser.yy"
+              { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location))); }
+#line 852 "dhcp6_parser.cc"
+    break;
+
+  case 34: // value: "null"
+#line 327 "dhcp6_parser.yy"
+                 { yylhs.value.as < ElementPtr > () = ElementPtr(new NullElement(ctx.loc2pos(yystack_[0].location))); }
+#line 858 "dhcp6_parser.cc"
+    break;
+
+  case 35: // value: map2
+#line 328 "dhcp6_parser.yy"
+            { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
+#line 864 "dhcp6_parser.cc"
+    break;
+
+  case 36: // value: list_generic
+#line 329 "dhcp6_parser.yy"
+                    { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
+#line 870 "dhcp6_parser.cc"
+    break;
+
+  case 37: // sub_json: value
+#line 332 "dhcp6_parser.yy"
+                {
+    // Push back the JSON value on the stack
+    ctx.stack_.push_back(yystack_[0].value.as < ElementPtr > ());
+}
+#line 879 "dhcp6_parser.cc"
+    break;
+
+  case 38: // $@15: %empty
+#line 337 "dhcp6_parser.yy"
+                     {
+    // This code is executed when we're about to start parsing
+    // the content of the map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 890 "dhcp6_parser.cc"
+    break;
+
+  case 39: // map2: "{" $@15 map_content "}"
+#line 342 "dhcp6_parser.yy"
+                             {
+    // map parsing completed. If we ever want to do any wrap up
+    // (maybe some sanity checking), this would be the best place
+    // for it.
+}
+#line 900 "dhcp6_parser.cc"
+    break;
+
+  case 40: // map_value: map2
+#line 348 "dhcp6_parser.yy"
+                { yylhs.value.as < ElementPtr > () = ctx.stack_.back(); ctx.stack_.pop_back(); }
+#line 906 "dhcp6_parser.cc"
+    break;
+
+  case 43: // not_empty_map: "constant string" ":" value
+#line 355 "dhcp6_parser.yy"
+                                  {
+                  // map containing a single entry
+                  ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
+                  ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
+                  }
+#line 916 "dhcp6_parser.cc"
+    break;
+
+  case 44: // not_empty_map: not_empty_map "," "constant string" ":" value
+#line 360 "dhcp6_parser.yy"
+                                                      {
+                  // map consisting of a shorter map followed by
+                  // comma and string:value
+                  ctx.unique(yystack_[2].value.as < std::string > (), ctx.loc2pos(yystack_[2].location));
+                  ctx.stack_.back()->set(yystack_[2].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
+                  }
+#line 927 "dhcp6_parser.cc"
+    break;
+
+  case 45: // not_empty_map: not_empty_map ","
+#line 366 "dhcp6_parser.yy"
+                                   {
+                 ctx.warnAboutExtraCommas(yystack_[0].location);
+                 }
+#line 935 "dhcp6_parser.cc"
+    break;
+
+  case 46: // $@16: %empty
+#line 371 "dhcp6_parser.yy"
+                              {
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(l);
+}
+#line 944 "dhcp6_parser.cc"
+    break;
+
+  case 47: // list_generic: "[" $@16 list_content "]"
+#line 374 "dhcp6_parser.yy"
+                               {
+    // list parsing complete. Put any sanity checking here
+}
+#line 952 "dhcp6_parser.cc"
+    break;
+
+  case 50: // not_empty_list: value
+#line 382 "dhcp6_parser.yy"
+                      {
+                  // List consisting of a single element.
+                  ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
+                  }
+#line 961 "dhcp6_parser.cc"
+    break;
+
+  case 51: // not_empty_list: not_empty_list "," value
+#line 386 "dhcp6_parser.yy"
+                                           {
+                  // List ending with , and a value.
+                  ctx.stack_.back()->add(yystack_[0].value.as < ElementPtr > ());
+                  }
+#line 970 "dhcp6_parser.cc"
+    break;
+
+  case 52: // not_empty_list: not_empty_list ","
+#line 390 "dhcp6_parser.yy"
+                                     {
+                  ctx.warnAboutExtraCommas(yystack_[0].location);
+                  }
+#line 978 "dhcp6_parser.cc"
+    break;
+
+  case 53: // $@17: %empty
+#line 396 "dhcp6_parser.yy"
+                              {
+    // List parsing about to start
+}
+#line 986 "dhcp6_parser.cc"
+    break;
+
+  case 54: // list_strings: "[" $@17 list_strings_content "]"
+#line 398 "dhcp6_parser.yy"
+                                       {
+    // list parsing complete. Put any sanity checking here
+    //ctx.stack_.pop_back();
+}
+#line 995 "dhcp6_parser.cc"
+    break;
+
+  case 57: // not_empty_list_strings: "constant string"
+#line 407 "dhcp6_parser.yy"
+                               {
+                          ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+                          ctx.stack_.back()->add(s);
+                          }
+#line 1004 "dhcp6_parser.cc"
+    break;
+
+  case 58: // not_empty_list_strings: not_empty_list_strings "," "constant string"
+#line 411 "dhcp6_parser.yy"
+                                                            {
+                          ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+                          ctx.stack_.back()->add(s);
+                          }
+#line 1013 "dhcp6_parser.cc"
+    break;
+
+  case 59: // not_empty_list_strings: not_empty_list_strings ","
+#line 415 "dhcp6_parser.yy"
+                                                     {
+                          ctx.warnAboutExtraCommas(yystack_[0].location);
+                          }
+#line 1021 "dhcp6_parser.cc"
+    break;
+
+  case 60: // unknown_map_entry: "constant string" ":"
+#line 425 "dhcp6_parser.yy"
+                                {
+    const std::string& where = ctx.contextName();
+    const std::string& keyword = yystack_[1].value.as < std::string > ();
+    error(yystack_[1].location,
+          "got unexpected keyword \"" + keyword + "\" in " + where + " map.");
+}
+#line 1032 "dhcp6_parser.cc"
+    break;
+
+  case 61: // $@18: %empty
+#line 434 "dhcp6_parser.yy"
+                           {
+    // This code is executed when we're about to start parsing
+    // the content of the map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 1043 "dhcp6_parser.cc"
+    break;
+
+  case 62: // syntax_map: "{" $@18 global_object "}"
+#line 439 "dhcp6_parser.yy"
+                               {
+    // map parsing completed. If we ever want to do any wrap up
+    // (maybe some sanity checking), this would be the best place
+    // for it.
+
+    // Dhcp6 is required
+    ctx.require("Dhcp6", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+}
+#line 1056 "dhcp6_parser.cc"
+    break;
+
+  case 63: // $@19: %empty
+#line 449 "dhcp6_parser.yy"
+                     {
+    // This code is executed when we're about to start parsing
+    // the content of the map
+    // Prevent against duplicate.
+    ctx.unique("Dhcp6", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("Dhcp6", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.DHCP6);
+}
+#line 1071 "dhcp6_parser.cc"
+    break;
+
+  case 64: // global_object: "Dhcp6" $@19 ":" "{" global_params "}"
+#line 458 "dhcp6_parser.yy"
+                                                    {
+    // No global parameter is required
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 1081 "dhcp6_parser.cc"
+    break;
+
+  case 66: // global_object_comma: global_object ","
+#line 466 "dhcp6_parser.yy"
+                                         {
+    ctx.warnAboutExtraCommas(yystack_[0].location);
+}
+#line 1089 "dhcp6_parser.cc"
+    break;
+
+  case 67: // $@20: %empty
+#line 472 "dhcp6_parser.yy"
+                          {
+    // Parse the Dhcp6 map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 1099 "dhcp6_parser.cc"
+    break;
+
+  case 68: // sub_dhcp6: "{" $@20 global_params "}"
+#line 476 "dhcp6_parser.yy"
+                               {
+    // No global parameter is required
+    // parsing completed
+}
+#line 1108 "dhcp6_parser.cc"
+    break;
+
+  case 71: // global_params: global_params ","
+#line 483 "dhcp6_parser.yy"
+                                   {
+                 ctx.warnAboutExtraCommas(yystack_[0].location);
+                 }
+#line 1116 "dhcp6_parser.cc"
+    break;
+
+  case 137: // $@21: %empty
+#line 557 "dhcp6_parser.yy"
+                               {
+    ctx.unique("data-directory", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1125 "dhcp6_parser.cc"
+    break;
+
+  case 138: // data_directory: "data-directory" $@21 ":" "constant string"
+#line 560 "dhcp6_parser.yy"
+               {
+    ElementPtr datadir(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("data-directory", datadir);
+    ctx.leave();
+}
+#line 1135 "dhcp6_parser.cc"
+    break;
+
+  case 139: // preferred_lifetime: "preferred-lifetime" ":" "integer"
+#line 566 "dhcp6_parser.yy"
+                                                     {
+    ctx.unique("preferred-lifetime", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("preferred-lifetime", prf);
+}
+#line 1145 "dhcp6_parser.cc"
+    break;
+
+  case 140: // min_preferred_lifetime: "min-preferred-lifetime" ":" "integer"
+#line 572 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("min-preferred-lifetime", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("min-preferred-lifetime", prf);
+}
+#line 1155 "dhcp6_parser.cc"
+    break;
+
+  case 141: // max_preferred_lifetime: "max-preferred-lifetime" ":" "integer"
+#line 578 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("max-preferred-lifetime", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-preferred-lifetime", prf);
+}
+#line 1165 "dhcp6_parser.cc"
+    break;
+
+  case 142: // valid_lifetime: "valid-lifetime" ":" "integer"
+#line 584 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("valid-lifetime", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("valid-lifetime", prf);
+}
+#line 1175 "dhcp6_parser.cc"
+    break;
+
+  case 143: // min_valid_lifetime: "min-valid-lifetime" ":" "integer"
+#line 590 "dhcp6_parser.yy"
+                                                     {
+    ctx.unique("min-valid-lifetime", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("min-valid-lifetime", prf);
+}
+#line 1185 "dhcp6_parser.cc"
+    break;
+
+  case 144: // max_valid_lifetime: "max-valid-lifetime" ":" "integer"
+#line 596 "dhcp6_parser.yy"
+                                                     {
+    ctx.unique("max-valid-lifetime", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-valid-lifetime", prf);
+}
+#line 1195 "dhcp6_parser.cc"
+    break;
+
+  case 145: // renew_timer: "renew-timer" ":" "integer"
+#line 602 "dhcp6_parser.yy"
+                                       {
+    ctx.unique("renew-timer", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("renew-timer", prf);
+}
+#line 1205 "dhcp6_parser.cc"
+    break;
+
+  case 146: // rebind_timer: "rebind-timer" ":" "integer"
+#line 608 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("rebind-timer", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("rebind-timer", prf);
+}
+#line 1215 "dhcp6_parser.cc"
+    break;
+
+  case 147: // calculate_tee_times: "calculate-tee-times" ":" "boolean"
+#line 614 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("calculate-tee-times", ctx.loc2pos(yystack_[2].location));
+    ElementPtr ctt(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("calculate-tee-times", ctt);
+}
+#line 1225 "dhcp6_parser.cc"
+    break;
+
+  case 148: // t1_percent: "t1-percent" ":" "floating point"
+#line 620 "dhcp6_parser.yy"
+                                   {
+    ctx.unique("t1-percent", ctx.loc2pos(yystack_[2].location));
+    ElementPtr t1(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("t1-percent", t1);
+}
+#line 1235 "dhcp6_parser.cc"
+    break;
+
+  case 149: // t2_percent: "t2-percent" ":" "floating point"
+#line 626 "dhcp6_parser.yy"
+                                   {
+    ctx.unique("t2-percent", ctx.loc2pos(yystack_[2].location));
+    ElementPtr t2(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("t2-percent", t2);
+}
+#line 1245 "dhcp6_parser.cc"
+    break;
+
+  case 150: // cache_threshold: "cache-threshold" ":" "floating point"
+#line 632 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("cache-threshold", ctx.loc2pos(yystack_[2].location));
+    ElementPtr ct(new DoubleElement(yystack_[0].value.as < double > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("cache-threshold", ct);
+}
+#line 1255 "dhcp6_parser.cc"
+    break;
+
+  case 151: // cache_max_age: "cache-max-age" ":" "integer"
+#line 638 "dhcp6_parser.yy"
+                                           {
+    ctx.unique("cache-max-age", ctx.loc2pos(yystack_[2].location));
+    ElementPtr cm(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("cache-max-age", cm);
+}
+#line 1265 "dhcp6_parser.cc"
+    break;
+
+  case 152: // decline_probation_period: "decline-probation-period" ":" "integer"
+#line 644 "dhcp6_parser.yy"
+                                                                 {
+    ctx.unique("decline-probation-period", ctx.loc2pos(yystack_[2].location));
+    ElementPtr dpp(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("decline-probation-period", dpp);
+}
+#line 1275 "dhcp6_parser.cc"
+    break;
+
+  case 153: // ddns_send_updates: "ddns-send-updates" ":" "boolean"
+#line 650 "dhcp6_parser.yy"
+                                                   {
+    ctx.unique("ddns-send-updates", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-send-updates", b);
+}
+#line 1285 "dhcp6_parser.cc"
+    break;
+
+  case 154: // ddns_override_no_update: "ddns-override-no-update" ":" "boolean"
+#line 656 "dhcp6_parser.yy"
+                                                               {
+    ctx.unique("ddns-override-no-update", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-override-no-update", b);
+}
+#line 1295 "dhcp6_parser.cc"
+    break;
+
+  case 155: // ddns_override_client_update: "ddns-override-client-update" ":" "boolean"
+#line 662 "dhcp6_parser.yy"
+                                                                       {
+    ctx.unique("ddns-override-client-update", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-override-client-update", b);
+}
+#line 1305 "dhcp6_parser.cc"
+    break;
+
+  case 156: // $@22: %empty
+#line 668 "dhcp6_parser.yy"
+                                                   {
+    ctx.unique("ddns-replace-client-name", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.REPLACE_CLIENT_NAME);
+}
+#line 1314 "dhcp6_parser.cc"
+    break;
+
+  case 157: // ddns_replace_client_name: "ddns-replace-client-name" $@22 ":" ddns_replace_client_name_value
+#line 671 "dhcp6_parser.yy"
+                                       {
+    ctx.stack_.back()->set("ddns-replace-client-name", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 1323 "dhcp6_parser.cc"
+    break;
+
+  case 158: // ddns_replace_client_name_value: "when-present"
+#line 677 "dhcp6_parser.yy"
+                 {
+      yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-present", ctx.loc2pos(yystack_[0].location)));
+      }
+#line 1331 "dhcp6_parser.cc"
+    break;
+
+  case 159: // ddns_replace_client_name_value: "never"
+#line 680 "dhcp6_parser.yy"
+          {
+      yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("never", ctx.loc2pos(yystack_[0].location)));
+      }
+#line 1339 "dhcp6_parser.cc"
+    break;
+
+  case 160: // ddns_replace_client_name_value: "always"
+#line 683 "dhcp6_parser.yy"
+           {
+      yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("always", ctx.loc2pos(yystack_[0].location)));
+      }
+#line 1347 "dhcp6_parser.cc"
+    break;
+
+  case 161: // ddns_replace_client_name_value: "when-not-present"
+#line 686 "dhcp6_parser.yy"
+                     {
+      yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("when-not-present", ctx.loc2pos(yystack_[0].location)));
+      }
+#line 1355 "dhcp6_parser.cc"
+    break;
+
+  case 162: // ddns_replace_client_name_value: "boolean"
+#line 689 "dhcp6_parser.yy"
+            {
+      error(yystack_[0].location, "boolean values for the replace-client-name are "
+                "no longer supported");
+      }
+#line 1364 "dhcp6_parser.cc"
+    break;
+
+  case 163: // $@23: %empty
+#line 695 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("ddns-generated-prefix", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1373 "dhcp6_parser.cc"
+    break;
+
+  case 164: // ddns_generated_prefix: "ddns-generated-prefix" $@23 ":" "constant string"
+#line 698 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-generated-prefix", s);
+    ctx.leave();
+}
+#line 1383 "dhcp6_parser.cc"
+    break;
+
+  case 165: // $@24: %empty
+#line 704 "dhcp6_parser.yy"
+                                               {
+    ctx.unique("ddns-qualifying-suffix", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1392 "dhcp6_parser.cc"
+    break;
+
+  case 166: // ddns_qualifying_suffix: "ddns-qualifying-suffix" $@24 ":" "constant string"
+#line 707 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-qualifying-suffix", s);
+    ctx.leave();
+}
+#line 1402 "dhcp6_parser.cc"
+    break;
+
+  case 167: // ddns_update_on_renew: "ddns-update-on-renew" ":" "boolean"
+#line 713 "dhcp6_parser.yy"
+                                                         {
+    ctx.unique("ddns-update-on-renew", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-update-on-renew", b);
+}
+#line 1412 "dhcp6_parser.cc"
+    break;
+
+  case 168: // ddns_use_conflict_resolution: "ddns-use-conflict-resolution" ":" "boolean"
+#line 719 "dhcp6_parser.yy"
+                                                                         {
+    ctx.unique("ddns-use-conflict-resolution", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ddns-use-conflict-resolution", b);
+}
+#line 1422 "dhcp6_parser.cc"
+    break;
+
+  case 169: // $@25: %empty
+#line 725 "dhcp6_parser.yy"
+                                     {
+    ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1431 "dhcp6_parser.cc"
+    break;
+
+  case 170: // hostname_char_set: "hostname-char-set" $@25 ":" "constant string"
+#line 728 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hostname-char-set", s);
+    ctx.leave();
+}
+#line 1441 "dhcp6_parser.cc"
+    break;
+
+  case 171: // $@26: %empty
+#line 734 "dhcp6_parser.yy"
+                                                     {
+    ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1450 "dhcp6_parser.cc"
+    break;
+
+  case 172: // hostname_char_replacement: "hostname-char-replacement" $@26 ":" "constant string"
+#line 737 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hostname-char-replacement", s);
+    ctx.leave();
+}
+#line 1460 "dhcp6_parser.cc"
+    break;
+
+  case 173: // store_extended_info: "store-extended-info" ":" "boolean"
+#line 743 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("store-extended-info", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("store-extended-info", b);
+}
+#line 1470 "dhcp6_parser.cc"
+    break;
+
+  case 174: // statistic_default_sample_count: "statistic-default-sample-count" ":" "integer"
+#line 749 "dhcp6_parser.yy"
+                                                                             {
+    ctx.unique("statistic-default-sample-count", ctx.loc2pos(yystack_[2].location));
+    ElementPtr count(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("statistic-default-sample-count", count);
+}
+#line 1480 "dhcp6_parser.cc"
+    break;
+
+  case 175: // statistic_default_sample_age: "statistic-default-sample-age" ":" "integer"
+#line 755 "dhcp6_parser.yy"
+                                                                         {
+    ctx.unique("statistic-default-sample-age", ctx.loc2pos(yystack_[2].location));
+    ElementPtr age(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("statistic-default-sample-age", age);
+}
+#line 1490 "dhcp6_parser.cc"
+    break;
+
+  case 176: // $@27: %empty
+#line 761 "dhcp6_parser.yy"
+                       {
+    ctx.unique("server-tag", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1499 "dhcp6_parser.cc"
+    break;
+
+  case 177: // server_tag: "server-tag" $@27 ":" "constant string"
+#line 764 "dhcp6_parser.yy"
+               {
+    ElementPtr stag(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("server-tag", stag);
+    ctx.leave();
+}
+#line 1509 "dhcp6_parser.cc"
+    break;
+
+  case 178: // parked_packet_limit: "parked-packet-limit" ":" "integer"
+#line 770 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("parked-packet-limit", ctx.loc2pos(yystack_[2].location));
+    ElementPtr ppl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("parked-packet-limit", ppl);
+}
+#line 1519 "dhcp6_parser.cc"
+    break;
+
+  case 179: // early_global_reservations_lookup: "early-global-reservations-lookup" ":" "boolean"
+#line 776 "dhcp6_parser.yy"
+                                                                                 {
+    ctx.unique("early-global-reservations-lookup", ctx.loc2pos(yystack_[2].location));
+    ElementPtr early(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("early-global-reservations-lookup", early);
+}
+#line 1529 "dhcp6_parser.cc"
+    break;
+
+  case 180: // ip_reservations_unique: "ip-reservations-unique" ":" "boolean"
+#line 782 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("ip-reservations-unique", ctx.loc2pos(yystack_[2].location));
+    ElementPtr unique(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ip-reservations-unique", unique);
+}
+#line 1539 "dhcp6_parser.cc"
+    break;
+
+  case 181: // reservations_lookup_first: "reservations-lookup-first" ":" "boolean"
+#line 788 "dhcp6_parser.yy"
+                                                                   {
+    ctx.unique("reservations-lookup-first", ctx.loc2pos(yystack_[2].location));
+    ElementPtr first(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reservations-lookup-first", first);
+}
+#line 1549 "dhcp6_parser.cc"
+    break;
+
+  case 182: // $@28: %empty
+#line 794 "dhcp6_parser.yy"
+                                     {
+    ctx.unique("interfaces-config", ctx.loc2pos(yystack_[0].location));
+    ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("interfaces-config", i);
+    ctx.stack_.push_back(i);
+    ctx.enter(ctx.INTERFACES_CONFIG);
+}
+#line 1561 "dhcp6_parser.cc"
+    break;
+
+  case 183: // interfaces_config: "interfaces-config" $@28 ":" "{" interfaces_config_params "}"
+#line 800 "dhcp6_parser.yy"
+                                                               {
+    // No interfaces config param is required
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 1571 "dhcp6_parser.cc"
+    break;
+
+  case 184: // $@29: %empty
+#line 806 "dhcp6_parser.yy"
+                                {
+    // Parse the interfaces-config map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 1581 "dhcp6_parser.cc"
+    break;
+
+  case 185: // sub_interfaces6: "{" $@29 interfaces_config_params "}"
+#line 810 "dhcp6_parser.yy"
+                                          {
+    // No interfaces config param is required
+    // parsing completed
+}
+#line 1590 "dhcp6_parser.cc"
+    break;
+
+  case 188: // interfaces_config_params: interfaces_config_params ","
+#line 817 "dhcp6_parser.yy"
+                                                         {
+                            ctx.warnAboutExtraCommas(yystack_[0].location);
+                            }
+#line 1598 "dhcp6_parser.cc"
+    break;
+
+  case 197: // $@30: %empty
+#line 832 "dhcp6_parser.yy"
+                            {
+    ctx.unique("interfaces", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("interfaces", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1610 "dhcp6_parser.cc"
+    break;
+
+  case 198: // interfaces_list: "interfaces" $@30 ":" list_strings
+#line 838 "dhcp6_parser.yy"
+                     {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 1619 "dhcp6_parser.cc"
+    break;
+
+  case 199: // re_detect: "re-detect" ":" "boolean"
+#line 843 "dhcp6_parser.yy"
+                                   {
+    ctx.unique("re-detect", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("re-detect", b);
+}
+#line 1629 "dhcp6_parser.cc"
+    break;
+
+  case 200: // service_sockets_require_all: "service-sockets-require-all" ":" "boolean"
+#line 849 "dhcp6_parser.yy"
+                                                                       {
+    ctx.unique("service-sockets-require-all", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("service-sockets-require-all", b);
+}
+#line 1639 "dhcp6_parser.cc"
+    break;
+
+  case 201: // service_sockets_retry_wait_time: "service-sockets-retry-wait-time" ":" "integer"
+#line 855 "dhcp6_parser.yy"
+                                                                               {
+    ctx.unique("service-sockets-retry-wait-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("service-sockets-retry-wait-time", n);
+}
+#line 1649 "dhcp6_parser.cc"
+    break;
+
+  case 202: // service_sockets_max_retries: "service-sockets-max-retries" ":" "integer"
+#line 861 "dhcp6_parser.yy"
+                                                                       {
+    ctx.unique("service-sockets-max-retries", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("service-sockets-max-retries", n);
+}
+#line 1659 "dhcp6_parser.cc"
+    break;
+
+  case 203: // $@31: %empty
+#line 867 "dhcp6_parser.yy"
+                               {
+    ctx.unique("lease-database", ctx.loc2pos(yystack_[0].location));
+    ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("lease-database", i);
+    ctx.stack_.push_back(i);
+    ctx.enter(ctx.LEASE_DATABASE);
+}
+#line 1671 "dhcp6_parser.cc"
+    break;
+
+  case 204: // lease_database: "lease-database" $@31 ":" "{" database_map_params "}"
+#line 873 "dhcp6_parser.yy"
+                                                          {
+    // The type parameter is required
+    ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 1682 "dhcp6_parser.cc"
+    break;
+
+  case 205: // $@32: %empty
+#line 880 "dhcp6_parser.yy"
+                               {
+    ctx.unique("hosts-database", ctx.loc2pos(yystack_[0].location));
+    ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hosts-database", i);
+    ctx.stack_.push_back(i);
+    ctx.enter(ctx.HOSTS_DATABASE);
+}
+#line 1694 "dhcp6_parser.cc"
+    break;
+
+  case 206: // hosts_database: "hosts-database" $@32 ":" "{" database_map_params "}"
+#line 886 "dhcp6_parser.yy"
+                                                          {
+    // The type parameter is required
+    ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 1705 "dhcp6_parser.cc"
+    break;
+
+  case 207: // $@33: %empty
+#line 893 "dhcp6_parser.yy"
+                                 {
+    ctx.unique("hosts-databases", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hosts-databases", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.HOSTS_DATABASE);
+}
+#line 1717 "dhcp6_parser.cc"
+    break;
+
+  case 208: // hosts_databases: "hosts-databases" $@33 ":" "[" database_list "]"
+#line 899 "dhcp6_parser.yy"
+                                                      {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 1726 "dhcp6_parser.cc"
+    break;
+
+  case 213: // not_empty_database_list: not_empty_database_list ","
+#line 910 "dhcp6_parser.yy"
+                                                       {
+                           ctx.warnAboutExtraCommas(yystack_[0].location);
+                           }
+#line 1734 "dhcp6_parser.cc"
+    break;
+
+  case 214: // $@34: %empty
+#line 915 "dhcp6_parser.yy"
+                         {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 1744 "dhcp6_parser.cc"
+    break;
+
+  case 215: // database: "{" $@34 database_map_params "}"
+#line 919 "dhcp6_parser.yy"
+                                     {
+    // The type parameter is required
+    ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 1754 "dhcp6_parser.cc"
+    break;
+
+  case 218: // database_map_params: database_map_params ","
+#line 927 "dhcp6_parser.yy"
+                                               {
+                       ctx.warnAboutExtraCommas(yystack_[0].location);
+                       }
+#line 1762 "dhcp6_parser.cc"
+    break;
+
+  case 238: // $@35: %empty
+#line 953 "dhcp6_parser.yy"
+                    {
+    ctx.unique("type", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.DATABASE_TYPE);
+}
+#line 1771 "dhcp6_parser.cc"
+    break;
+
+  case 239: // database_type: "type" $@35 ":" db_type
+#line 956 "dhcp6_parser.yy"
+                {
+    ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 1780 "dhcp6_parser.cc"
+    break;
+
+  case 240: // db_type: "memfile"
+#line 961 "dhcp6_parser.yy"
+                 { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("memfile", ctx.loc2pos(yystack_[0].location))); }
+#line 1786 "dhcp6_parser.cc"
+    break;
+
+  case 241: // db_type: "mysql"
+#line 962 "dhcp6_parser.yy"
+               { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("mysql", ctx.loc2pos(yystack_[0].location))); }
+#line 1792 "dhcp6_parser.cc"
+    break;
+
+  case 242: // db_type: "postgresql"
+#line 963 "dhcp6_parser.yy"
+                    { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("postgresql", ctx.loc2pos(yystack_[0].location))); }
+#line 1798 "dhcp6_parser.cc"
+    break;
+
+  case 243: // $@36: %empty
+#line 966 "dhcp6_parser.yy"
+           {
+    ctx.unique("user", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1807 "dhcp6_parser.cc"
+    break;
+
+  case 244: // user: "user" $@36 ":" "constant string"
+#line 969 "dhcp6_parser.yy"
+               {
+    ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("user", user);
+    ctx.leave();
+}
+#line 1817 "dhcp6_parser.cc"
+    break;
+
+  case 245: // $@37: %empty
+#line 975 "dhcp6_parser.yy"
+                   {
+    ctx.unique("password", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1826 "dhcp6_parser.cc"
+    break;
+
+  case 246: // password: "password" $@37 ":" "constant string"
+#line 978 "dhcp6_parser.yy"
+               {
+    ElementPtr pwd(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("password", pwd);
+    ctx.leave();
+}
+#line 1836 "dhcp6_parser.cc"
+    break;
+
+  case 247: // $@38: %empty
+#line 984 "dhcp6_parser.yy"
+           {
+    ctx.unique("host", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1845 "dhcp6_parser.cc"
+    break;
+
+  case 248: // host: "host" $@38 ":" "constant string"
+#line 987 "dhcp6_parser.yy"
+               {
+    ElementPtr h(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("host", h);
+    ctx.leave();
+}
+#line 1855 "dhcp6_parser.cc"
+    break;
+
+  case 249: // port: "port" ":" "integer"
+#line 993 "dhcp6_parser.yy"
+                         {
+    ctx.unique("port", ctx.loc2pos(yystack_[2].location));
+    ElementPtr p(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("port", p);
+}
+#line 1865 "dhcp6_parser.cc"
+    break;
+
+  case 250: // $@39: %empty
+#line 999 "dhcp6_parser.yy"
+           {
+    ctx.unique("name", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1874 "dhcp6_parser.cc"
+    break;
+
+  case 251: // name: "name" $@39 ":" "constant string"
+#line 1002 "dhcp6_parser.yy"
+               {
+    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("name", name);
+    ctx.leave();
+}
+#line 1884 "dhcp6_parser.cc"
+    break;
+
+  case 252: // persist: "persist" ":" "boolean"
+#line 1008 "dhcp6_parser.yy"
+                               {
+    ctx.unique("persist", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("persist", n);
+}
+#line 1894 "dhcp6_parser.cc"
+    break;
+
+  case 253: // lfc_interval: "lfc-interval" ":" "integer"
+#line 1014 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("lfc-interval", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("lfc-interval", n);
+}
+#line 1904 "dhcp6_parser.cc"
+    break;
+
+  case 254: // readonly: "readonly" ":" "boolean"
+#line 1020 "dhcp6_parser.yy"
+                                 {
+    ctx.unique("readonly", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("readonly", n);
+}
+#line 1914 "dhcp6_parser.cc"
+    break;
+
+  case 255: // connect_timeout: "connect-timeout" ":" "integer"
+#line 1026 "dhcp6_parser.yy"
+                                               {
+    ctx.unique("connect-timeout", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("connect-timeout", n);
+}
+#line 1924 "dhcp6_parser.cc"
+    break;
+
+  case 256: // reconnect_wait_time: "reconnect-wait-time" ":" "integer"
+#line 1032 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("reconnect-wait-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reconnect-wait-time", n);
+}
+#line 1934 "dhcp6_parser.cc"
+    break;
+
+  case 257: // $@40: %empty
+#line 1038 "dhcp6_parser.yy"
+                 {
+    ctx.unique("on-fail", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.DATABASE_ON_FAIL);
+}
+#line 1943 "dhcp6_parser.cc"
+    break;
+
+  case 258: // on_fail: "on-fail" $@40 ":" on_fail_mode
+#line 1041 "dhcp6_parser.yy"
+                     {
+    ctx.stack_.back()->set("on-fail", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 1952 "dhcp6_parser.cc"
+    break;
+
+  case 259: // on_fail_mode: "stop-retry-exit"
+#line 1046 "dhcp6_parser.yy"
+                              { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("stop-retry-exit", ctx.loc2pos(yystack_[0].location))); }
+#line 1958 "dhcp6_parser.cc"
+    break;
+
+  case 260: // on_fail_mode: "serve-retry-exit"
+#line 1047 "dhcp6_parser.yy"
+                               { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-exit", ctx.loc2pos(yystack_[0].location))); }
+#line 1964 "dhcp6_parser.cc"
+    break;
+
+  case 261: // on_fail_mode: "serve-retry-continue"
+#line 1048 "dhcp6_parser.yy"
+                                   { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("serve-retry-continue", ctx.loc2pos(yystack_[0].location))); }
+#line 1970 "dhcp6_parser.cc"
+    break;
+
+  case 262: // max_row_errors: "max-row-errors" ":" "integer"
+#line 1051 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("max-row-errors", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-row-errors", n);
+}
+#line 1980 "dhcp6_parser.cc"
+    break;
+
+  case 263: // max_reconnect_tries: "max-reconnect-tries" ":" "integer"
+#line 1057 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("max-reconnect-tries", ctx.loc2pos(yystack_[2].location));
+    ElementPtr n(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-reconnect-tries", n);
+}
+#line 1990 "dhcp6_parser.cc"
+    break;
+
+  case 264: // $@41: %empty
+#line 1063 "dhcp6_parser.yy"
+                           {
+    ctx.unique("trust-anchor", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 1999 "dhcp6_parser.cc"
+    break;
+
+  case 265: // trust_anchor: "trust-anchor" $@41 ":" "constant string"
+#line 1066 "dhcp6_parser.yy"
+               {
+    ElementPtr ca(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("trust-anchor", ca);
+    ctx.leave();
+}
+#line 2009 "dhcp6_parser.cc"
+    break;
+
+  case 266: // $@42: %empty
+#line 1072 "dhcp6_parser.yy"
+                     {
+    ctx.unique("cert-file", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2018 "dhcp6_parser.cc"
+    break;
+
+  case 267: // cert_file: "cert-file" $@42 ":" "constant string"
+#line 1075 "dhcp6_parser.yy"
+               {
+    ElementPtr cert(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("cert-file", cert);
+    ctx.leave();
+}
+#line 2028 "dhcp6_parser.cc"
+    break;
+
+  case 268: // $@43: %empty
+#line 1081 "dhcp6_parser.yy"
+                   {
+    ctx.unique("key-file", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2037 "dhcp6_parser.cc"
+    break;
+
+  case 269: // key_file: "key-file" $@43 ":" "constant string"
+#line 1084 "dhcp6_parser.yy"
+               {
+    ElementPtr key(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("key-file", key);
+    ctx.leave();
+}
+#line 2047 "dhcp6_parser.cc"
+    break;
+
+  case 270: // $@44: %empty
+#line 1090 "dhcp6_parser.yy"
+                         {
+    ctx.unique("cipher-list", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2056 "dhcp6_parser.cc"
+    break;
+
+  case 271: // cipher_list: "cipher-list" $@44 ":" "constant string"
+#line 1093 "dhcp6_parser.yy"
+               {
+    ElementPtr cl(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("cipher-list", cl);
+    ctx.leave();
+}
+#line 2066 "dhcp6_parser.cc"
+    break;
+
+  case 272: // $@45: %empty
+#line 1099 "dhcp6_parser.yy"
+                             {
+    ctx.unique("sanity-checks", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("sanity-checks", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.SANITY_CHECKS);
+}
+#line 2078 "dhcp6_parser.cc"
+    break;
+
+  case 273: // sanity_checks: "sanity-checks" $@45 ":" "{" sanity_checks_params "}"
+#line 1105 "dhcp6_parser.yy"
+                                                           {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2087 "dhcp6_parser.cc"
+    break;
+
+  case 276: // sanity_checks_params: sanity_checks_params ","
+#line 1112 "dhcp6_parser.yy"
+                                                 {
+                        ctx.warnAboutExtraCommas(yystack_[0].location);
+                        }
+#line 2095 "dhcp6_parser.cc"
+    break;
+
+  case 278: // $@46: %empty
+#line 1119 "dhcp6_parser.yy"
+                           {
+    ctx.unique("lease-checks", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2104 "dhcp6_parser.cc"
+    break;
+
+  case 279: // lease_checks: "lease-checks" $@46 ":" "constant string"
+#line 1122 "dhcp6_parser.yy"
+               {
+
+    if ( (string(yystack_[0].value.as < std::string > ()) == "none") ||
+         (string(yystack_[0].value.as < std::string > ()) == "warn") ||
+         (string(yystack_[0].value.as < std::string > ()) == "fix") ||
+         (string(yystack_[0].value.as < std::string > ()) == "fix-del") ||
+         (string(yystack_[0].value.as < std::string > ()) == "del")) {
+        ElementPtr user(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+        ctx.stack_.back()->set("lease-checks", user);
+        ctx.leave();
+    } else {
+        error(yystack_[0].location, "Unsupported 'lease-checks value: " + string(yystack_[0].value.as < std::string > ()) +
+              ", supported values are: none, warn, fix, fix-del, del");
+    }
+}
+#line 2124 "dhcp6_parser.cc"
+    break;
+
+  case 280: // $@47: %empty
+#line 1138 "dhcp6_parser.yy"
+                         {
+    ctx.unique("mac-sources", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("mac-sources", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.MAC_SOURCES);
+}
+#line 2136 "dhcp6_parser.cc"
+    break;
+
+  case 281: // mac_sources: "mac-sources" $@47 ":" "[" mac_sources_list "]"
+#line 1144 "dhcp6_parser.yy"
+                                                         {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2145 "dhcp6_parser.cc"
+    break;
+
+  case 284: // mac_sources_list: mac_sources_list ","
+#line 1151 "dhcp6_parser.yy"
+                                         {
+                    ctx.warnAboutExtraCommas(yystack_[0].location);
+                    }
+#line 2153 "dhcp6_parser.cc"
+    break;
+
+  case 287: // duid_id: "duid"
+#line 1160 "dhcp6_parser.yy"
+              {
+    ElementPtr duid(new StringElement("duid", ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(duid);
+}
+#line 2162 "dhcp6_parser.cc"
+    break;
+
+  case 288: // string_id: "constant string"
+#line 1165 "dhcp6_parser.yy"
+                  {
+    ElementPtr duid(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(duid);
+}
+#line 2171 "dhcp6_parser.cc"
+    break;
+
+  case 289: // $@48: %empty
+#line 1170 "dhcp6_parser.yy"
+                                                           {
+    ctx.unique("host-reservation-identifiers", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("host-reservation-identifiers", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.HOST_RESERVATION_IDENTIFIERS);
+}
+#line 2183 "dhcp6_parser.cc"
+    break;
+
+  case 290: // host_reservation_identifiers: "host-reservation-identifiers" $@48 ":" "[" host_reservation_identifiers_list "]"
+#line 1176 "dhcp6_parser.yy"
+                                                                          {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2192 "dhcp6_parser.cc"
+    break;
+
+  case 293: // host_reservation_identifiers_list: host_reservation_identifiers_list ","
+#line 1183 "dhcp6_parser.yy"
+                                              {
+        ctx.warnAboutExtraCommas(yystack_[0].location);
+        }
+#line 2200 "dhcp6_parser.cc"
+    break;
+
+  case 297: // hw_address_id: "hw-address"
+#line 1193 "dhcp6_parser.yy"
+                          {
+    ElementPtr hwaddr(new StringElement("hw-address", ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(hwaddr);
+}
+#line 2209 "dhcp6_parser.cc"
+    break;
+
+  case 298: // flex_id: "flex-id"
+#line 1198 "dhcp6_parser.yy"
+                 {
+    ElementPtr flex_id(new StringElement("flex-id", ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(flex_id);
+}
+#line 2218 "dhcp6_parser.cc"
+    break;
+
+  case 299: // $@49: %empty
+#line 1205 "dhcp6_parser.yy"
+                                               {
+    ctx.unique("relay-supplied-options", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("relay-supplied-options", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2230 "dhcp6_parser.cc"
+    break;
+
+  case 300: // relay_supplied_options: "relay-supplied-options" $@49 ":" "[" list_content "]"
+#line 1211 "dhcp6_parser.yy"
+                                                     {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2239 "dhcp6_parser.cc"
+    break;
+
+  case 301: // $@50: %empty
+#line 1218 "dhcp6_parser.yy"
+                                           {
+    ctx.unique("multi-threading", ctx.loc2pos(yystack_[0].location));
+    ElementPtr mt(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("multi-threading", mt);
+    ctx.stack_.push_back(mt);
+    ctx.enter(ctx.DHCP_MULTI_THREADING);
+}
+#line 2251 "dhcp6_parser.cc"
+    break;
+
+  case 302: // dhcp_multi_threading: "multi-threading" $@50 ":" "{" multi_threading_params "}"
+#line 1224 "dhcp6_parser.yy"
+                                                             {
+    // The enable parameter is required.
+    ctx.require("enable-multi-threading", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2262 "dhcp6_parser.cc"
+    break;
+
+  case 305: // multi_threading_params: multi_threading_params ","
+#line 1233 "dhcp6_parser.yy"
+                                                     {
+                          ctx.warnAboutExtraCommas(yystack_[0].location);
+                          }
+#line 2270 "dhcp6_parser.cc"
+    break;
+
+  case 312: // enable_multi_threading: "enable-multi-threading" ":" "boolean"
+#line 1246 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("enable-multi-threading", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("enable-multi-threading", b);
+}
+#line 2280 "dhcp6_parser.cc"
+    break;
+
+  case 313: // thread_pool_size: "thread-pool-size" ":" "integer"
+#line 1252 "dhcp6_parser.yy"
+                                                 {
+    ctx.unique("thread-pool-size", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("thread-pool-size", prf);
+}
+#line 2290 "dhcp6_parser.cc"
+    break;
+
+  case 314: // packet_queue_size: "packet-queue-size" ":" "integer"
+#line 1258 "dhcp6_parser.yy"
+                                                   {
+    ctx.unique("packet-queue-size", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("packet-queue-size", prf);
+}
+#line 2300 "dhcp6_parser.cc"
+    break;
+
+  case 315: // $@51: %empty
+#line 1264 "dhcp6_parser.yy"
+                                 {
+    ctx.unique("hooks-libraries", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hooks-libraries", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.HOOKS_LIBRARIES);
+}
+#line 2312 "dhcp6_parser.cc"
+    break;
+
+  case 316: // hooks_libraries: "hooks-libraries" $@51 ":" "[" hooks_libraries_list "]"
+#line 1270 "dhcp6_parser.yy"
+                                                             {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2321 "dhcp6_parser.cc"
+    break;
+
+  case 321: // not_empty_hooks_libraries_list: not_empty_hooks_libraries_list ","
+#line 1281 "dhcp6_parser.yy"
+                                           {
+        ctx.warnAboutExtraCommas(yystack_[0].location);
+        }
+#line 2329 "dhcp6_parser.cc"
+    break;
+
+  case 322: // $@52: %empty
+#line 1286 "dhcp6_parser.yy"
+                              {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 2339 "dhcp6_parser.cc"
+    break;
+
+  case 323: // hooks_library: "{" $@52 hooks_params "}"
+#line 1290 "dhcp6_parser.yy"
+                              {
+    // The library hooks parameter is required
+    ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 2349 "dhcp6_parser.cc"
+    break;
+
+  case 324: // $@53: %empty
+#line 1296 "dhcp6_parser.yy"
+                                  {
+    // Parse the hooks-libraries list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 2359 "dhcp6_parser.cc"
+    break;
+
+  case 325: // sub_hooks_library: "{" $@53 hooks_params "}"
+#line 1300 "dhcp6_parser.yy"
+                              {
+    // The library hooks parameter is required
+    ctx.require("library", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    // parsing completed
+}
+#line 2369 "dhcp6_parser.cc"
+    break;
+
+  case 328: // hooks_params: hooks_params ","
+#line 1308 "dhcp6_parser.yy"
+                                 {
+                ctx.warnAboutExtraCommas(yystack_[0].location);
+                }
+#line 2377 "dhcp6_parser.cc"
+    break;
+
+  case 332: // $@54: %empty
+#line 1318 "dhcp6_parser.yy"
+                 {
+    ctx.unique("library", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2386 "dhcp6_parser.cc"
+    break;
+
+  case 333: // library: "library" $@54 ":" "constant string"
+#line 1321 "dhcp6_parser.yy"
+               {
+    ElementPtr lib(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("library", lib);
+    ctx.leave();
+}
+#line 2396 "dhcp6_parser.cc"
+    break;
+
+  case 334: // $@55: %empty
+#line 1327 "dhcp6_parser.yy"
+                       {
+    ctx.unique("parameters", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2405 "dhcp6_parser.cc"
+    break;
+
+  case 335: // parameters: "parameters" $@55 ":" map_value
+#line 1330 "dhcp6_parser.yy"
+                  {
+    ctx.stack_.back()->set("parameters", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 2414 "dhcp6_parser.cc"
+    break;
+
+  case 336: // $@56: %empty
+#line 1336 "dhcp6_parser.yy"
+                                                     {
+    ctx.unique("expired-leases-processing", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("expired-leases-processing", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.EXPIRED_LEASES_PROCESSING);
+}
+#line 2426 "dhcp6_parser.cc"
+    break;
+
+  case 337: // expired_leases_processing: "expired-leases-processing" $@56 ":" "{" expired_leases_params "}"
+#line 1342 "dhcp6_parser.yy"
+                                                            {
+    // No expired lease parameter is required
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2436 "dhcp6_parser.cc"
+    break;
+
+  case 340: // expired_leases_params: expired_leases_params ","
+#line 1350 "dhcp6_parser.yy"
+                                                   {
+                         ctx.warnAboutExtraCommas(yystack_[0].location);
+                         }
+#line 2444 "dhcp6_parser.cc"
+    break;
+
+  case 347: // reclaim_timer_wait_time: "reclaim-timer-wait-time" ":" "integer"
+#line 1363 "dhcp6_parser.yy"
+                                                               {
+    ctx.unique("reclaim-timer-wait-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reclaim-timer-wait-time", value);
+}
+#line 2454 "dhcp6_parser.cc"
+    break;
+
+  case 348: // flush_reclaimed_timer_wait_time: "flush-reclaimed-timer-wait-time" ":" "integer"
+#line 1369 "dhcp6_parser.yy"
+                                                                               {
+    ctx.unique("flush-reclaimed-timer-wait-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("flush-reclaimed-timer-wait-time", value);
+}
+#line 2464 "dhcp6_parser.cc"
+    break;
+
+  case 349: // hold_reclaimed_time: "hold-reclaimed-time" ":" "integer"
+#line 1375 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("hold-reclaimed-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hold-reclaimed-time", value);
+}
+#line 2474 "dhcp6_parser.cc"
+    break;
+
+  case 350: // max_reclaim_leases: "max-reclaim-leases" ":" "integer"
+#line 1381 "dhcp6_parser.yy"
+                                                     {
+    ctx.unique("max-reclaim-leases", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-reclaim-leases", value);
+}
+#line 2484 "dhcp6_parser.cc"
+    break;
+
+  case 351: // max_reclaim_time: "max-reclaim-time" ":" "integer"
+#line 1387 "dhcp6_parser.yy"
+                                                 {
+    ctx.unique("max-reclaim-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-reclaim-time", value);
+}
+#line 2494 "dhcp6_parser.cc"
+    break;
+
+  case 352: // unwarned_reclaim_cycles: "unwarned-reclaim-cycles" ":" "integer"
+#line 1393 "dhcp6_parser.yy"
+                                                               {
+    ctx.unique("unwarned-reclaim-cycles", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("unwarned-reclaim-cycles", value);
+}
+#line 2504 "dhcp6_parser.cc"
+    break;
+
+  case 353: // $@57: %empty
+#line 1402 "dhcp6_parser.yy"
+                      {
+    ctx.unique("subnet6", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("subnet6", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.SUBNET6);
+}
+#line 2516 "dhcp6_parser.cc"
+    break;
+
+  case 354: // subnet6_list: "subnet6" $@57 ":" "[" subnet6_list_content "]"
+#line 1408 "dhcp6_parser.yy"
+                                                             {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2525 "dhcp6_parser.cc"
+    break;
+
+  case 359: // not_empty_subnet6_list: not_empty_subnet6_list ","
+#line 1422 "dhcp6_parser.yy"
+                                                     {
+                          ctx.warnAboutExtraCommas(yystack_[0].location);
+                          }
+#line 2533 "dhcp6_parser.cc"
+    break;
+
+  case 360: // $@58: %empty
+#line 1431 "dhcp6_parser.yy"
+                        {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 2543 "dhcp6_parser.cc"
+    break;
+
+  case 361: // subnet6: "{" $@58 subnet6_params "}"
+#line 1435 "dhcp6_parser.yy"
+                                {
+    // Once we reached this place, the subnet parsing is now complete.
+    // If we want to, we can implement default values here.
+    // In particular we can do things like this:
+    // if (!ctx.stack_.back()->get("interface")) {
+    //     ctx.stack_.back()->set("interface", StringElement("loopback"));
+    // }
+    //
+    // We can also stack up one level (Dhcp6) and copy over whatever
+    // global parameters we want to:
+    // if (!ctx.stack_.back()->get("renew-timer")) {
+    //     ElementPtr renew = ctx_stack_[...].get("renew-timer");
+    //     if (renew) {
+    //         ctx.stack_.back()->set("renew-timer", renew);
+    //     }
+    // }
+
+    // The subnet subnet6 parameter is required
+    ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 2569 "dhcp6_parser.cc"
+    break;
+
+  case 362: // $@59: %empty
+#line 1457 "dhcp6_parser.yy"
+                            {
+    // Parse the subnet6 list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 2579 "dhcp6_parser.cc"
+    break;
+
+  case 363: // sub_subnet6: "{" $@59 subnet6_params "}"
+#line 1461 "dhcp6_parser.yy"
+                                {
+    // The subnet subnet6 parameter is required
+    ctx.require("subnet", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    // parsing completed
+}
+#line 2589 "dhcp6_parser.cc"
+    break;
+
+  case 366: // subnet6_params: subnet6_params ","
+#line 1470 "dhcp6_parser.yy"
+                                     {
+                  ctx.warnAboutExtraCommas(yystack_[0].location);
+                  }
+#line 2597 "dhcp6_parser.cc"
+    break;
+
+  case 410: // $@60: %empty
+#line 1521 "dhcp6_parser.yy"
+               {
+    ctx.unique("subnet", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2606 "dhcp6_parser.cc"
+    break;
+
+  case 411: // subnet: "subnet" $@60 ":" "constant string"
+#line 1524 "dhcp6_parser.yy"
+               {
+    ElementPtr subnet(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("subnet", subnet);
+    ctx.leave();
+}
+#line 2616 "dhcp6_parser.cc"
+    break;
+
+  case 412: // $@61: %empty
+#line 1530 "dhcp6_parser.yy"
+                     {
+    ctx.unique("interface", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2625 "dhcp6_parser.cc"
+    break;
+
+  case 413: // interface: "interface" $@61 ":" "constant string"
+#line 1533 "dhcp6_parser.yy"
+               {
+    ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("interface", iface);
+    ctx.leave();
+}
+#line 2635 "dhcp6_parser.cc"
+    break;
+
+  case 414: // $@62: %empty
+#line 1539 "dhcp6_parser.yy"
+                           {
+    ctx.unique("interface-id", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2644 "dhcp6_parser.cc"
+    break;
+
+  case 415: // interface_id: "interface-id" $@62 ":" "constant string"
+#line 1542 "dhcp6_parser.yy"
+               {
+    ElementPtr iface(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("interface-id", iface);
+    ctx.leave();
+}
+#line 2654 "dhcp6_parser.cc"
+    break;
+
+  case 416: // $@63: %empty
+#line 1548 "dhcp6_parser.yy"
+                           {
+    ctx.unique("client-class", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2663 "dhcp6_parser.cc"
+    break;
+
+  case 417: // client_class: "client-class" $@63 ":" "constant string"
+#line 1551 "dhcp6_parser.yy"
+               {
+    ElementPtr cls(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("client-class", cls);
+    ctx.leave();
+}
+#line 2673 "dhcp6_parser.cc"
+    break;
+
+  case 418: // $@64: %empty
+#line 1557 "dhcp6_parser.yy"
+                                               {
+    ctx.unique("require-client-classes", ctx.loc2pos(yystack_[0].location));
+    ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("require-client-classes", c);
+    ctx.stack_.push_back(c);
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2685 "dhcp6_parser.cc"
+    break;
+
+  case 419: // require_client_classes: "require-client-classes" $@64 ":" list_strings
+#line 1563 "dhcp6_parser.yy"
+                     {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2694 "dhcp6_parser.cc"
+    break;
+
+  case 420: // reservations_global: "reservations-global" ":" "boolean"
+#line 1568 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("reservations-global", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reservations-global", b);
+}
+#line 2704 "dhcp6_parser.cc"
+    break;
+
+  case 421: // reservations_in_subnet: "reservations-in-subnet" ":" "boolean"
+#line 1574 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("reservations-in-subnet", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reservations-in-subnet", b);
+}
+#line 2714 "dhcp6_parser.cc"
+    break;
+
+  case 422: // reservations_out_of_pool: "reservations-out-of-pool" ":" "boolean"
+#line 1580 "dhcp6_parser.yy"
+                                                                 {
+    ctx.unique("reservations-out-of-pool", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reservations-out-of-pool", b);
+}
+#line 2724 "dhcp6_parser.cc"
+    break;
+
+  case 423: // $@65: %empty
+#line 1586 "dhcp6_parser.yy"
+                                   {
+    ctx.unique("reservation-mode", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.RESERVATION_MODE);
+}
+#line 2733 "dhcp6_parser.cc"
+    break;
+
+  case 424: // reservation_mode: "reservation-mode" $@65 ":" hr_mode
+#line 1589 "dhcp6_parser.yy"
+                {
+    ctx.stack_.back()->set("reservation-mode", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 2742 "dhcp6_parser.cc"
+    break;
+
+  case 425: // hr_mode: "disabled"
+#line 1594 "dhcp6_parser.yy"
+                  { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("disabled", ctx.loc2pos(yystack_[0].location))); }
+#line 2748 "dhcp6_parser.cc"
+    break;
+
+  case 426: // hr_mode: "out-of-pool"
+#line 1595 "dhcp6_parser.yy"
+                     { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("out-of-pool", ctx.loc2pos(yystack_[0].location))); }
+#line 2754 "dhcp6_parser.cc"
+    break;
+
+  case 427: // hr_mode: "global"
+#line 1596 "dhcp6_parser.yy"
+                { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("global", ctx.loc2pos(yystack_[0].location))); }
+#line 2760 "dhcp6_parser.cc"
+    break;
+
+  case 428: // hr_mode: "all"
+#line 1597 "dhcp6_parser.yy"
+             { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("all", ctx.loc2pos(yystack_[0].location))); }
+#line 2766 "dhcp6_parser.cc"
+    break;
+
+  case 429: // id: "id" ":" "integer"
+#line 1600 "dhcp6_parser.yy"
+                     {
+    ctx.unique("id", ctx.loc2pos(yystack_[2].location));
+    ElementPtr id(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("id", id);
+}
+#line 2776 "dhcp6_parser.cc"
+    break;
+
+  case 430: // rapid_commit: "rapid-commit" ":" "boolean"
+#line 1606 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("rapid-commit", ctx.loc2pos(yystack_[2].location));
+    ElementPtr rc(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("rapid-commit", rc);
+}
+#line 2786 "dhcp6_parser.cc"
+    break;
+
+  case 431: // $@66: %empty
+#line 1614 "dhcp6_parser.yy"
+                                 {
+    ctx.unique("shared-networks", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("shared-networks", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.SHARED_NETWORK);
+}
+#line 2798 "dhcp6_parser.cc"
+    break;
+
+  case 432: // shared_networks: "shared-networks" $@66 ":" "[" shared_networks_content "]"
+#line 1620 "dhcp6_parser.yy"
+                                                                {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2807 "dhcp6_parser.cc"
+    break;
+
+  case 437: // shared_networks_list: shared_networks_list ","
+#line 1633 "dhcp6_parser.yy"
+                                                 {
+                        ctx.warnAboutExtraCommas(yystack_[0].location);
+                        }
+#line 2815 "dhcp6_parser.cc"
+    break;
+
+  case 438: // $@67: %empty
+#line 1638 "dhcp6_parser.yy"
+                               {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 2825 "dhcp6_parser.cc"
+    break;
+
+  case 439: // shared_network: "{" $@67 shared_network_params "}"
+#line 1642 "dhcp6_parser.yy"
+                                       {
+    ctx.stack_.pop_back();
+}
+#line 2833 "dhcp6_parser.cc"
+    break;
+
+  case 442: // shared_network_params: shared_network_params ","
+#line 1648 "dhcp6_parser.yy"
+                                                   {
+                         ctx.warnAboutExtraCommas(yystack_[0].location);
+                         }
+#line 2841 "dhcp6_parser.cc"
+    break;
+
+  case 483: // $@68: %empty
+#line 1699 "dhcp6_parser.yy"
+                            {
+    ctx.unique("option-def", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("option-def", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.OPTION_DEF);
+}
+#line 2853 "dhcp6_parser.cc"
+    break;
+
+  case 484: // option_def_list: "option-def" $@68 ":" "[" option_def_list_content "]"
+#line 1705 "dhcp6_parser.yy"
+                                                                {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 2862 "dhcp6_parser.cc"
+    break;
+
+  case 485: // $@69: %empty
+#line 1713 "dhcp6_parser.yy"
+                                    {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 2871 "dhcp6_parser.cc"
+    break;
+
+  case 486: // sub_option_def_list: "{" $@69 option_def_list "}"
+#line 1716 "dhcp6_parser.yy"
+                                 {
+    // parsing completed
+}
+#line 2879 "dhcp6_parser.cc"
+    break;
+
+  case 491: // not_empty_option_def_list: not_empty_option_def_list ","
+#line 1728 "dhcp6_parser.yy"
+                                                           {
+                             ctx.warnAboutExtraCommas(yystack_[0].location);
+                             }
+#line 2887 "dhcp6_parser.cc"
+    break;
+
+  case 492: // $@70: %empty
+#line 1735 "dhcp6_parser.yy"
+                                 {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 2897 "dhcp6_parser.cc"
+    break;
+
+  case 493: // option_def_entry: "{" $@70 option_def_params "}"
+#line 1739 "dhcp6_parser.yy"
+                                   {
+    // The name, code and type option def parameters are required.
+    ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("code", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 2909 "dhcp6_parser.cc"
+    break;
+
+  case 494: // $@71: %empty
+#line 1750 "dhcp6_parser.yy"
+                               {
+    // Parse the option-def list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 2919 "dhcp6_parser.cc"
+    break;
+
+  case 495: // sub_option_def: "{" $@71 option_def_params "}"
+#line 1754 "dhcp6_parser.yy"
+                                   {
+    // The name, code and type option def parameters are required.
+    ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("code", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("type", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    // parsing completed
+}
+#line 2931 "dhcp6_parser.cc"
+    break;
+
+  case 500: // not_empty_option_def_params: not_empty_option_def_params ","
+#line 1770 "dhcp6_parser.yy"
+                                                               {
+                               ctx.warnAboutExtraCommas(yystack_[0].location);
+                               }
+#line 2939 "dhcp6_parser.cc"
+    break;
+
+  case 512: // code: "code" ":" "integer"
+#line 1789 "dhcp6_parser.yy"
+                         {
+    ctx.unique("code", ctx.loc2pos(yystack_[2].location));
+    ElementPtr code(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("code", code);
+}
+#line 2949 "dhcp6_parser.cc"
+    break;
+
+  case 514: // $@72: %empty
+#line 1797 "dhcp6_parser.yy"
+                      {
+    ctx.unique("type", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2958 "dhcp6_parser.cc"
+    break;
+
+  case 515: // option_def_type: "type" $@72 ":" "constant string"
+#line 1800 "dhcp6_parser.yy"
+               {
+    ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("type", prf);
+    ctx.leave();
+}
+#line 2968 "dhcp6_parser.cc"
+    break;
+
+  case 516: // $@73: %empty
+#line 1806 "dhcp6_parser.yy"
+                                      {
+    ctx.unique("record-types", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2977 "dhcp6_parser.cc"
+    break;
+
+  case 517: // option_def_record_types: "record-types" $@73 ":" "constant string"
+#line 1809 "dhcp6_parser.yy"
+               {
+    ElementPtr rtypes(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("record-types", rtypes);
+    ctx.leave();
+}
+#line 2987 "dhcp6_parser.cc"
+    break;
+
+  case 518: // $@74: %empty
+#line 1815 "dhcp6_parser.yy"
+             {
+    ctx.unique("space", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 2996 "dhcp6_parser.cc"
+    break;
+
+  case 519: // space: "space" $@74 ":" "constant string"
+#line 1818 "dhcp6_parser.yy"
+               {
+    ElementPtr space(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("space", space);
+    ctx.leave();
+}
+#line 3006 "dhcp6_parser.cc"
+    break;
+
+  case 521: // $@75: %empty
+#line 1826 "dhcp6_parser.yy"
+                                    {
+    ctx.unique("encapsulate", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3015 "dhcp6_parser.cc"
+    break;
+
+  case 522: // option_def_encapsulate: "encapsulate" $@75 ":" "constant string"
+#line 1829 "dhcp6_parser.yy"
+               {
+    ElementPtr encap(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("encapsulate", encap);
+    ctx.leave();
+}
+#line 3025 "dhcp6_parser.cc"
+    break;
+
+  case 523: // option_def_array: "array" ":" "boolean"
+#line 1835 "dhcp6_parser.yy"
+                                      {
+    ctx.unique("array", ctx.loc2pos(yystack_[2].location));
+    ElementPtr array(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("array", array);
+}
+#line 3035 "dhcp6_parser.cc"
+    break;
+
+  case 524: // $@76: %empty
+#line 1845 "dhcp6_parser.yy"
+                              {
+    ctx.unique("option-data", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("option-data", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.OPTION_DATA);
+}
+#line 3047 "dhcp6_parser.cc"
+    break;
+
+  case 525: // option_data_list: "option-data" $@76 ":" "[" option_data_list_content "]"
+#line 1851 "dhcp6_parser.yy"
+                                                                 {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3056 "dhcp6_parser.cc"
+    break;
+
+  case 530: // not_empty_option_data_list: not_empty_option_data_list ","
+#line 1866 "dhcp6_parser.yy"
+                                                             {
+                              ctx.warnAboutExtraCommas(yystack_[0].location);
+                              }
+#line 3064 "dhcp6_parser.cc"
+    break;
+
+  case 531: // $@77: %empty
+#line 1873 "dhcp6_parser.yy"
+                                  {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 3074 "dhcp6_parser.cc"
+    break;
+
+  case 532: // option_data_entry: "{" $@77 option_data_params "}"
+#line 1877 "dhcp6_parser.yy"
+                                    {
+    /// @todo: the code or name parameters are required.
+    ctx.stack_.pop_back();
+}
+#line 3083 "dhcp6_parser.cc"
+    break;
+
+  case 533: // $@78: %empty
+#line 1885 "dhcp6_parser.yy"
+                                {
+    // Parse the option-data list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 3093 "dhcp6_parser.cc"
+    break;
+
+  case 534: // sub_option_data: "{" $@78 option_data_params "}"
+#line 1889 "dhcp6_parser.yy"
+                                    {
+    /// @todo: the code or name parameters are required.
+    // parsing completed
+}
+#line 3102 "dhcp6_parser.cc"
+    break;
+
+  case 539: // not_empty_option_data_params: not_empty_option_data_params ","
+#line 1905 "dhcp6_parser.yy"
+                                         {
+        ctx.warnAboutExtraCommas(yystack_[0].location);
+        }
+#line 3110 "dhcp6_parser.cc"
+    break;
+
+  case 550: // $@79: %empty
+#line 1925 "dhcp6_parser.yy"
+                       {
+    ctx.unique("data", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3119 "dhcp6_parser.cc"
+    break;
+
+  case 551: // option_data_data: "data" $@79 ":" "constant string"
+#line 1928 "dhcp6_parser.yy"
+               {
+    ElementPtr data(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("data", data);
+    ctx.leave();
+}
+#line 3129 "dhcp6_parser.cc"
+    break;
+
+  case 554: // option_data_csv_format: "csv-format" ":" "boolean"
+#line 1938 "dhcp6_parser.yy"
+                                                 {
+    ctx.unique("csv-format", ctx.loc2pos(yystack_[2].location));
+    ElementPtr space(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("csv-format", space);
+}
+#line 3139 "dhcp6_parser.cc"
+    break;
+
+  case 555: // option_data_always_send: "always-send" ":" "boolean"
+#line 1944 "dhcp6_parser.yy"
+                                                   {
+    ctx.unique("always-send", ctx.loc2pos(yystack_[2].location));
+    ElementPtr persist(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("always-send", persist);
+}
+#line 3149 "dhcp6_parser.cc"
+    break;
+
+  case 556: // $@80: %empty
+#line 1953 "dhcp6_parser.yy"
+                  {
+    ctx.unique("pools", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("pools", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.POOLS);
+}
+#line 3161 "dhcp6_parser.cc"
+    break;
+
+  case 557: // pools_list: "pools" $@80 ":" "[" pools_list_content "]"
+#line 1959 "dhcp6_parser.yy"
+                                                           {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3170 "dhcp6_parser.cc"
+    break;
+
+  case 562: // not_empty_pools_list: not_empty_pools_list ","
+#line 1972 "dhcp6_parser.yy"
+                                                 {
+                        ctx.warnAboutExtraCommas(yystack_[0].location);
+                        }
+#line 3178 "dhcp6_parser.cc"
+    break;
+
+  case 563: // $@81: %empty
+#line 1977 "dhcp6_parser.yy"
+                                {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 3188 "dhcp6_parser.cc"
+    break;
+
+  case 564: // pool_list_entry: "{" $@81 pool_params "}"
+#line 1981 "dhcp6_parser.yy"
+                             {
+    // The pool parameter is required.
+    ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 3198 "dhcp6_parser.cc"
+    break;
+
+  case 565: // $@82: %empty
+#line 1987 "dhcp6_parser.yy"
+                          {
+    // Parse the pool list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 3208 "dhcp6_parser.cc"
+    break;
+
+  case 566: // sub_pool6: "{" $@82 pool_params "}"
+#line 1991 "dhcp6_parser.yy"
+                             {
+    // The pool parameter is required.
+    ctx.require("pool", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    // parsing completed
+}
+#line 3218 "dhcp6_parser.cc"
+    break;
+
+  case 569: // pool_params: pool_params ","
+#line 1999 "dhcp6_parser.yy"
+                               {
+               ctx.warnAboutExtraCommas(yystack_[0].location);
+               }
+#line 3226 "dhcp6_parser.cc"
+    break;
+
+  case 577: // $@83: %empty
+#line 2013 "dhcp6_parser.yy"
+                 {
+    ctx.unique("pool", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3235 "dhcp6_parser.cc"
+    break;
+
+  case 578: // pool_entry: "pool" $@83 ":" "constant string"
+#line 2016 "dhcp6_parser.yy"
+               {
+    ElementPtr pool(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("pool", pool);
+    ctx.leave();
+}
+#line 3245 "dhcp6_parser.cc"
+    break;
+
+  case 579: // $@84: %empty
+#line 2022 "dhcp6_parser.yy"
+                           {
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3253 "dhcp6_parser.cc"
+    break;
+
+  case 580: // user_context: "user-context" $@84 ":" map_value
+#line 2024 "dhcp6_parser.yy"
+                  {
+    ElementPtr parent = ctx.stack_.back();
+    ElementPtr user_context = yystack_[0].value.as < ElementPtr > ();
+    ConstElementPtr old = parent->get("user-context");
+
+    // Handle already existing user context
+    if (old) {
+        // Check if it was a comment or a duplicate
+        if ((old->size() != 1) || !old->contains("comment")) {
+            std::stringstream msg;
+            msg << "duplicate user-context entries (previous at "
+                << old->getPosition().str() << ")";
+            error(yystack_[3].location, msg.str());
+        }
+        // Merge the comment
+        user_context->set("comment", old->get("comment"));
+    }
+
+    // Set the user context
+    parent->set("user-context", user_context);
+    ctx.leave();
+}
+#line 3280 "dhcp6_parser.cc"
+    break;
+
+  case 581: // $@85: %empty
+#line 2047 "dhcp6_parser.yy"
+                 {
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3288 "dhcp6_parser.cc"
+    break;
+
+  case 582: // comment: "comment" $@85 ":" "constant string"
+#line 2049 "dhcp6_parser.yy"
+               {
+    ElementPtr parent = ctx.stack_.back();
+    ElementPtr user_context(new MapElement(ctx.loc2pos(yystack_[3].location)));
+    ElementPtr comment(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    user_context->set("comment", comment);
+
+    // Handle already existing user context
+    ConstElementPtr old = parent->get("user-context");
+    if (old) {
+        // Check for duplicate comment
+        if (old->contains("comment")) {
+            std::stringstream msg;
+            msg << "duplicate user-context/comment entries (previous at "
+                << old->getPosition().str() << ")";
+            error(yystack_[3].location, msg.str());
+        }
+        // Merge the user context in the comment
+        merge(user_context, old);
+    }
+
+    // Set the user context
+    parent->set("user-context", user_context);
+    ctx.leave();
+}
+#line 3317 "dhcp6_parser.cc"
+    break;
+
+  case 583: // $@86: %empty
+#line 2077 "dhcp6_parser.yy"
+                        {
+    ctx.unique("pd-pools", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("pd-pools", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.PD_POOLS);
+}
+#line 3329 "dhcp6_parser.cc"
+    break;
+
+  case 584: // pd_pools_list: "pd-pools" $@86 ":" "[" pd_pools_list_content "]"
+#line 2083 "dhcp6_parser.yy"
+                                                              {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3338 "dhcp6_parser.cc"
+    break;
+
+  case 589: // not_empty_pd_pools_list: not_empty_pd_pools_list ","
+#line 2096 "dhcp6_parser.yy"
+                                                       {
+                           ctx.warnAboutExtraCommas(yystack_[0].location);
+                           }
+#line 3346 "dhcp6_parser.cc"
+    break;
+
+  case 590: // $@87: %empty
+#line 2101 "dhcp6_parser.yy"
+                              {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 3356 "dhcp6_parser.cc"
+    break;
+
+  case 591: // pd_pool_entry: "{" $@87 pd_pool_params "}"
+#line 2105 "dhcp6_parser.yy"
+                                {
+    // The prefix, prefix len and delegated len parameters are required.
+    ctx.require("prefix", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("prefix-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 3368 "dhcp6_parser.cc"
+    break;
+
+  case 592: // $@88: %empty
+#line 2113 "dhcp6_parser.yy"
+                            {
+    // Parse the pd-pool list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 3378 "dhcp6_parser.cc"
+    break;
+
+  case 593: // sub_pd_pool: "{" $@88 pd_pool_params "}"
+#line 2117 "dhcp6_parser.yy"
+                                {
+    // The prefix, prefix len and delegated len parameters are required.
+    ctx.require("prefix", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("prefix-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.require("delegated-len", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    // parsing completed
+}
+#line 3390 "dhcp6_parser.cc"
+    break;
+
+  case 596: // pd_pool_params: pd_pool_params ","
+#line 2127 "dhcp6_parser.yy"
+                                     {
+                  ctx.warnAboutExtraCommas(yystack_[0].location);
+                  }
+#line 3398 "dhcp6_parser.cc"
+    break;
+
+  case 608: // $@89: %empty
+#line 2145 "dhcp6_parser.yy"
+                  {
+    ctx.unique("prefix", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3407 "dhcp6_parser.cc"
+    break;
+
+  case 609: // pd_prefix: "prefix" $@89 ":" "constant string"
+#line 2148 "dhcp6_parser.yy"
+               {
+    ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("prefix", prf);
+    ctx.leave();
+}
+#line 3417 "dhcp6_parser.cc"
+    break;
+
+  case 610: // pd_prefix_len: "prefix-len" ":" "integer"
+#line 2154 "dhcp6_parser.yy"
+                                        {
+    ctx.unique("prefix-len", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("prefix-len", prf);
+}
+#line 3427 "dhcp6_parser.cc"
+    break;
+
+  case 611: // $@90: %empty
+#line 2160 "dhcp6_parser.yy"
+                                 {
+    ctx.unique("excluded-prefix", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3436 "dhcp6_parser.cc"
+    break;
+
+  case 612: // excluded_prefix: "excluded-prefix" $@90 ":" "constant string"
+#line 2163 "dhcp6_parser.yy"
+               {
+    ElementPtr prf(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("excluded-prefix", prf);
+    ctx.leave();
+}
+#line 3446 "dhcp6_parser.cc"
+    break;
+
+  case 613: // excluded_prefix_len: "excluded-prefix-len" ":" "integer"
+#line 2169 "dhcp6_parser.yy"
+                                                       {
+    ctx.unique("excluded-prefix-len", ctx.loc2pos(yystack_[2].location));
+    ElementPtr prf(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("excluded-prefix-len", prf);
+}
+#line 3456 "dhcp6_parser.cc"
+    break;
+
+  case 614: // pd_delegated_len: "delegated-len" ":" "integer"
+#line 2175 "dhcp6_parser.yy"
+                                              {
+    ctx.unique("delegated-len", ctx.loc2pos(yystack_[2].location));
+    ElementPtr deleg(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("delegated-len", deleg);
+}
+#line 3466 "dhcp6_parser.cc"
+    break;
+
+  case 615: // $@91: %empty
+#line 2184 "dhcp6_parser.yy"
+                           {
+    ctx.unique("reservations", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("reservations", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.RESERVATIONS);
+}
+#line 3478 "dhcp6_parser.cc"
+    break;
+
+  case 616: // reservations: "reservations" $@91 ":" "[" reservations_list "]"
+#line 2190 "dhcp6_parser.yy"
+                                                          {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3487 "dhcp6_parser.cc"
+    break;
+
+  case 621: // not_empty_reservations_list: not_empty_reservations_list ","
+#line 2201 "dhcp6_parser.yy"
+                                                               {
+                               ctx.warnAboutExtraCommas(yystack_[0].location);
+                               }
+#line 3495 "dhcp6_parser.cc"
+    break;
+
+  case 622: // $@92: %empty
+#line 2206 "dhcp6_parser.yy"
+                            {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 3505 "dhcp6_parser.cc"
+    break;
+
+  case 623: // reservation: "{" $@92 reservation_params "}"
+#line 2210 "dhcp6_parser.yy"
+                                    {
+    /// @todo: an identifier parameter is required.
+    ctx.stack_.pop_back();
+}
+#line 3514 "dhcp6_parser.cc"
+    break;
+
+  case 624: // $@93: %empty
+#line 2215 "dhcp6_parser.yy"
+                                {
+    // Parse the reservations list entry map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 3524 "dhcp6_parser.cc"
+    break;
+
+  case 625: // sub_reservation: "{" $@93 reservation_params "}"
+#line 2219 "dhcp6_parser.yy"
+                                    {
+    /// @todo: an identifier parameter is required.
+    // parsing completed
+}
+#line 3533 "dhcp6_parser.cc"
+    break;
+
+  case 630: // not_empty_reservation_params: not_empty_reservation_params ","
+#line 2230 "dhcp6_parser.yy"
+                                         {
+        ctx.warnAboutExtraCommas(yystack_[0].location);
+        }
+#line 3541 "dhcp6_parser.cc"
+    break;
+
+  case 642: // $@94: %empty
+#line 2249 "dhcp6_parser.yy"
+                           {
+    ctx.unique("ip-addresses", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ip-addresses", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3553 "dhcp6_parser.cc"
+    break;
+
+  case 643: // ip_addresses: "ip-addresses" $@94 ":" list_strings
+#line 2255 "dhcp6_parser.yy"
+                     {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3562 "dhcp6_parser.cc"
+    break;
+
+  case 644: // $@95: %empty
+#line 2260 "dhcp6_parser.yy"
+                   {
+    ctx.unique("prefixes", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("prefixes", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3574 "dhcp6_parser.cc"
+    break;
+
+  case 645: // prefixes: "prefixes" $@95 ":" list_strings
+#line 2266 "dhcp6_parser.yy"
+                     {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3583 "dhcp6_parser.cc"
+    break;
+
+  case 646: // $@96: %empty
+#line 2271 "dhcp6_parser.yy"
+           {
+    ctx.unique("duid", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3592 "dhcp6_parser.cc"
+    break;
+
+  case 647: // duid: "duid" $@96 ":" "constant string"
+#line 2274 "dhcp6_parser.yy"
+               {
+    ElementPtr d(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("duid", d);
+    ctx.leave();
+}
+#line 3602 "dhcp6_parser.cc"
+    break;
+
+  case 648: // $@97: %empty
+#line 2280 "dhcp6_parser.yy"
+                       {
+    ctx.unique("hw-address", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3611 "dhcp6_parser.cc"
+    break;
+
+  case 649: // hw_address: "hw-address" $@97 ":" "constant string"
+#line 2283 "dhcp6_parser.yy"
+               {
+    ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hw-address", hw);
+    ctx.leave();
+}
+#line 3621 "dhcp6_parser.cc"
+    break;
+
+  case 650: // $@98: %empty
+#line 2289 "dhcp6_parser.yy"
+                   {
+    ctx.unique("hostname", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3630 "dhcp6_parser.cc"
+    break;
+
+  case 651: // hostname: "hostname" $@98 ":" "constant string"
+#line 2292 "dhcp6_parser.yy"
+               {
+    ElementPtr host(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hostname", host);
+    ctx.leave();
+}
+#line 3640 "dhcp6_parser.cc"
+    break;
+
+  case 652: // $@99: %empty
+#line 2298 "dhcp6_parser.yy"
+                       {
+    ctx.unique("flex-id", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3649 "dhcp6_parser.cc"
+    break;
+
+  case 653: // flex_id_value: "flex-id" $@99 ":" "constant string"
+#line 2301 "dhcp6_parser.yy"
+               {
+    ElementPtr hw(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("flex-id", hw);
+    ctx.leave();
+}
+#line 3659 "dhcp6_parser.cc"
+    break;
+
+  case 654: // $@100: %empty
+#line 2307 "dhcp6_parser.yy"
+                                           {
+    ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location));
+    ElementPtr c(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("client-classes", c);
+    ctx.stack_.push_back(c);
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3671 "dhcp6_parser.cc"
+    break;
+
+  case 655: // reservation_client_classes: "client-classes" $@100 ":" list_strings
+#line 2313 "dhcp6_parser.yy"
+                     {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3680 "dhcp6_parser.cc"
+    break;
+
+  case 656: // $@101: %empty
+#line 2321 "dhcp6_parser.yy"
+             {
+    ctx.unique("relay", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("relay", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.RELAY);
+}
+#line 3692 "dhcp6_parser.cc"
+    break;
+
+  case 657: // relay: "relay" $@101 ":" "{" relay_map "}"
+#line 2327 "dhcp6_parser.yy"
+                                                {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3701 "dhcp6_parser.cc"
+    break;
+
+  case 660: // $@102: %empty
+#line 2336 "dhcp6_parser.yy"
+                       {
+    ctx.unique("ip-address", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3710 "dhcp6_parser.cc"
+    break;
+
+  case 661: // ip_address: "ip-address" $@102 ":" "constant string"
+#line 2339 "dhcp6_parser.yy"
+               {
+    ElementPtr addr(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ip-address", addr);
+    ctx.leave();
+}
+#line 3720 "dhcp6_parser.cc"
+    break;
+
+  case 662: // $@103: %empty
+#line 2348 "dhcp6_parser.yy"
+                               {
+    ctx.unique("client-classes", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("client-classes", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.CLIENT_CLASSES);
+}
+#line 3732 "dhcp6_parser.cc"
+    break;
+
+  case 663: // client_classes: "client-classes" $@103 ":" "[" client_classes_list "]"
+#line 2354 "dhcp6_parser.yy"
+                                                            {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3741 "dhcp6_parser.cc"
+    break;
+
+  case 666: // client_classes_list: client_classes_list ","
+#line 2361 "dhcp6_parser.yy"
+                                               {
+                       ctx.warnAboutExtraCommas(yystack_[0].location);
+                       }
+#line 3749 "dhcp6_parser.cc"
+    break;
+
+  case 667: // $@104: %empty
+#line 2366 "dhcp6_parser.yy"
+                                   {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 3759 "dhcp6_parser.cc"
+    break;
+
+  case 668: // client_class_entry: "{" $@104 client_class_params "}"
+#line 2370 "dhcp6_parser.yy"
+                                     {
+    // The name client class parameter is required.
+    ctx.require("name", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+}
+#line 3769 "dhcp6_parser.cc"
+    break;
+
+  case 673: // not_empty_client_class_params: not_empty_client_class_params ","
+#line 2382 "dhcp6_parser.yy"
+                                          {
+        ctx.warnAboutExtraCommas(yystack_[0].location);
+        }
+#line 3777 "dhcp6_parser.cc"
+    break;
+
+  case 688: // $@105: %empty
+#line 2404 "dhcp6_parser.yy"
+                        {
+    ctx.unique("test", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3786 "dhcp6_parser.cc"
+    break;
+
+  case 689: // client_class_test: "test" $@105 ":" "constant string"
+#line 2407 "dhcp6_parser.yy"
+               {
+    ElementPtr test(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("test", test);
+    ctx.leave();
+}
+#line 3796 "dhcp6_parser.cc"
+    break;
+
+  case 690: // only_if_required: "only-if-required" ":" "boolean"
+#line 2413 "dhcp6_parser.yy"
+                                                 {
+    ctx.unique("only-if-required", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("only-if-required", b);
+}
+#line 3806 "dhcp6_parser.cc"
+    break;
+
+  case 691: // $@106: %empty
+#line 2422 "dhcp6_parser.yy"
+                     {
+    ctx.unique("server-id", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("server-id", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.SERVER_ID);
+}
+#line 3818 "dhcp6_parser.cc"
+    break;
+
+  case 692: // server_id: "server-id" $@106 ":" "{" server_id_params "}"
+#line 2428 "dhcp6_parser.yy"
+                                                       {
+    // The type parameter is required.
+    ctx.require("type", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3829 "dhcp6_parser.cc"
+    break;
+
+  case 695: // server_id_params: server_id_params ","
+#line 2437 "dhcp6_parser.yy"
+                                         {
+                    ctx.warnAboutExtraCommas(yystack_[0].location);
+                    }
+#line 3837 "dhcp6_parser.cc"
+    break;
+
+  case 705: // $@107: %empty
+#line 2453 "dhcp6_parser.yy"
+                     {
+    ctx.unique("type", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.DUID_TYPE);
+}
+#line 3846 "dhcp6_parser.cc"
+    break;
+
+  case 706: // server_id_type: "type" $@107 ":" duid_type
+#line 2456 "dhcp6_parser.yy"
+                  {
+    ctx.stack_.back()->set("type", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 3855 "dhcp6_parser.cc"
+    break;
+
+  case 707: // duid_type: "LLT"
+#line 2461 "dhcp6_parser.yy"
+               { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("LLT", ctx.loc2pos(yystack_[0].location))); }
+#line 3861 "dhcp6_parser.cc"
+    break;
+
+  case 708: // duid_type: "EN"
+#line 2462 "dhcp6_parser.yy"
+              { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("EN", ctx.loc2pos(yystack_[0].location))); }
+#line 3867 "dhcp6_parser.cc"
+    break;
+
+  case 709: // duid_type: "LL"
+#line 2463 "dhcp6_parser.yy"
+              { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("LL", ctx.loc2pos(yystack_[0].location))); }
+#line 3873 "dhcp6_parser.cc"
+    break;
+
+  case 710: // htype: "htype" ":" "integer"
+#line 2466 "dhcp6_parser.yy"
+                           {
+    ctx.unique("htype", ctx.loc2pos(yystack_[2].location));
+    ElementPtr htype(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("htype", htype);
+}
+#line 3883 "dhcp6_parser.cc"
+    break;
+
+  case 711: // $@108: %empty
+#line 2472 "dhcp6_parser.yy"
+                       {
+    ctx.unique("identifier", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3892 "dhcp6_parser.cc"
+    break;
+
+  case 712: // identifier: "identifier" $@108 ":" "constant string"
+#line 2475 "dhcp6_parser.yy"
+               {
+    ElementPtr id(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("identifier", id);
+    ctx.leave();
+}
+#line 3902 "dhcp6_parser.cc"
+    break;
+
+  case 713: // time: "time" ":" "integer"
+#line 2481 "dhcp6_parser.yy"
+                         {
+    ctx.unique("time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("time", time);
+}
+#line 3912 "dhcp6_parser.cc"
+    break;
+
+  case 714: // enterprise_id: "enterprise-id" ":" "integer"
+#line 2487 "dhcp6_parser.yy"
+                                           {
+    ctx.unique("enterprise-id", ctx.loc2pos(yystack_[2].location));
+    ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("enterprise-id", time);
+}
+#line 3922 "dhcp6_parser.cc"
+    break;
+
+  case 715: // dhcp4o6_port: "dhcp4o6-port" ":" "integer"
+#line 2495 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("dhcp4o6-port", ctx.loc2pos(yystack_[2].location));
+    ElementPtr time(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("dhcp4o6-port", time);
+}
+#line 3932 "dhcp6_parser.cc"
+    break;
+
+  case 716: // $@109: %empty
+#line 2503 "dhcp6_parser.yy"
+                               {
+    ctx.unique("control-socket", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("control-socket", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.CONTROL_SOCKET);
+}
+#line 3944 "dhcp6_parser.cc"
+    break;
+
+  case 717: // control_socket: "control-socket" $@109 ":" "{" control_socket_params "}"
+#line 2509 "dhcp6_parser.yy"
+                                                            {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 3953 "dhcp6_parser.cc"
+    break;
+
+  case 720: // control_socket_params: control_socket_params ","
+#line 2516 "dhcp6_parser.yy"
+                                                   {
+                         ctx.warnAboutExtraCommas(yystack_[0].location);
+                         }
+#line 3961 "dhcp6_parser.cc"
+    break;
+
+  case 726: // $@110: %empty
+#line 2528 "dhcp6_parser.yy"
+                         {
+    ctx.unique("socket-type", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3970 "dhcp6_parser.cc"
+    break;
+
+  case 727: // socket_type: "socket-type" $@110 ":" "constant string"
+#line 2531 "dhcp6_parser.yy"
+               {
+    ElementPtr stype(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("socket-type", stype);
+    ctx.leave();
+}
+#line 3980 "dhcp6_parser.cc"
+    break;
+
+  case 728: // $@111: %empty
+#line 2537 "dhcp6_parser.yy"
+                         {
+    ctx.unique("socket-name", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 3989 "dhcp6_parser.cc"
+    break;
+
+  case 729: // socket_name: "socket-name" $@111 ":" "constant string"
+#line 2540 "dhcp6_parser.yy"
+               {
+    ElementPtr name(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("socket-name", name);
+    ctx.leave();
+}
+#line 3999 "dhcp6_parser.cc"
+    break;
+
+  case 730: // $@112: %empty
+#line 2549 "dhcp6_parser.yy"
+                                       {
+    ctx.unique("dhcp-queue-control", ctx.loc2pos(yystack_[0].location));
+    ElementPtr qc(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("dhcp-queue-control", qc);
+    ctx.stack_.push_back(qc);
+    ctx.enter(ctx.DHCP_QUEUE_CONTROL);
+}
+#line 4011 "dhcp6_parser.cc"
+    break;
+
+  case 731: // dhcp_queue_control: "dhcp-queue-control" $@112 ":" "{" queue_control_params "}"
+#line 2555 "dhcp6_parser.yy"
+                                                           {
+    // The enable queue parameter is required.
+    ctx.require("enable-queue", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4022 "dhcp6_parser.cc"
+    break;
+
+  case 734: // queue_control_params: queue_control_params ","
+#line 2564 "dhcp6_parser.yy"
+                                                 {
+                        ctx.warnAboutExtraCommas(yystack_[0].location);
+                        }
+#line 4030 "dhcp6_parser.cc"
+    break;
+
+  case 741: // enable_queue: "enable-queue" ":" "boolean"
+#line 2577 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("enable-queue", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("enable-queue", b);
+}
+#line 4040 "dhcp6_parser.cc"
+    break;
+
+  case 742: // $@113: %empty
+#line 2583 "dhcp6_parser.yy"
+                       {
+    ctx.unique("queue-type", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4049 "dhcp6_parser.cc"
+    break;
+
+  case 743: // queue_type: "queue-type" $@113 ":" "constant string"
+#line 2586 "dhcp6_parser.yy"
+               {
+    ElementPtr qt(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("queue-type", qt);
+    ctx.leave();
+}
+#line 4059 "dhcp6_parser.cc"
+    break;
+
+  case 744: // capacity: "capacity" ":" "integer"
+#line 2592 "dhcp6_parser.yy"
+                                 {
+    ctx.unique("capacity", ctx.loc2pos(yystack_[2].location));
+    ElementPtr c(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("capacity", c);
+}
+#line 4069 "dhcp6_parser.cc"
+    break;
+
+  case 745: // $@114: %empty
+#line 2598 "dhcp6_parser.yy"
+                            {
+    ctx.unique(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4078 "dhcp6_parser.cc"
+    break;
+
+  case 746: // arbitrary_map_entry: "constant string" $@114 ":" value
+#line 2601 "dhcp6_parser.yy"
+              {
+    ctx.stack_.back()->set(yystack_[3].value.as < std::string > (), yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 4087 "dhcp6_parser.cc"
+    break;
+
+  case 747: // $@115: %empty
+#line 2608 "dhcp6_parser.yy"
+                     {
+    ctx.unique("dhcp-ddns", ctx.loc2pos(yystack_[0].location));
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("dhcp-ddns", m);
+    ctx.stack_.push_back(m);
+    ctx.enter(ctx.DHCP_DDNS);
+}
+#line 4099 "dhcp6_parser.cc"
+    break;
+
+  case 748: // dhcp_ddns: "dhcp-ddns" $@115 ":" "{" dhcp_ddns_params "}"
+#line 2614 "dhcp6_parser.yy"
+                                                       {
+    // The enable updates DHCP DDNS parameter is required.
+    ctx.require("enable-updates", ctx.loc2pos(yystack_[2].location), ctx.loc2pos(yystack_[0].location));
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4110 "dhcp6_parser.cc"
+    break;
+
+  case 749: // $@116: %empty
+#line 2621 "dhcp6_parser.yy"
+                              {
+    // Parse the dhcp-ddns map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 4120 "dhcp6_parser.cc"
+    break;
+
+  case 750: // sub_dhcp_ddns: "{" $@116 dhcp_ddns_params "}"
+#line 2625 "dhcp6_parser.yy"
+                                  {
+    // The enable updates DHCP DDNS parameter is required.
+    ctx.require("enable-updates", ctx.loc2pos(yystack_[3].location), ctx.loc2pos(yystack_[0].location));
+    // parsing completed
+}
+#line 4130 "dhcp6_parser.cc"
+    break;
+
+  case 753: // dhcp_ddns_params: dhcp_ddns_params ","
+#line 2633 "dhcp6_parser.yy"
+                                         {
+                    ctx.warnAboutExtraCommas(yystack_[0].location);
+                    }
+#line 4138 "dhcp6_parser.cc"
+    break;
+
+  case 772: // enable_updates: "enable-updates" ":" "boolean"
+#line 2658 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("enable-updates", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("enable-updates", b);
+}
+#line 4148 "dhcp6_parser.cc"
+    break;
+
+  case 773: // $@117: %empty
+#line 2665 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("qualifying-suffix", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4157 "dhcp6_parser.cc"
+    break;
+
+  case 774: // dep_qualifying_suffix: "qualifying-suffix" $@117 ":" "constant string"
+#line 2668 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("qualifying-suffix", s);
+    ctx.leave();
+}
+#line 4167 "dhcp6_parser.cc"
+    break;
+
+  case 775: // $@118: %empty
+#line 2674 "dhcp6_parser.yy"
+                     {
+    ctx.unique("server-ip", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4176 "dhcp6_parser.cc"
+    break;
+
+  case 776: // server_ip: "server-ip" $@118 ":" "constant string"
+#line 2677 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("server-ip", s);
+    ctx.leave();
+}
+#line 4186 "dhcp6_parser.cc"
+    break;
+
+  case 777: // server_port: "server-port" ":" "integer"
+#line 2683 "dhcp6_parser.yy"
+                                       {
+    ctx.unique("server-port", ctx.loc2pos(yystack_[2].location));
+    ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("server-port", i);
+}
+#line 4196 "dhcp6_parser.cc"
+    break;
+
+  case 778: // $@119: %empty
+#line 2689 "dhcp6_parser.yy"
+                     {
+    ctx.unique("sender-ip", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4205 "dhcp6_parser.cc"
+    break;
+
+  case 779: // sender_ip: "sender-ip" $@119 ":" "constant string"
+#line 2692 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("sender-ip", s);
+    ctx.leave();
+}
+#line 4215 "dhcp6_parser.cc"
+    break;
+
+  case 780: // sender_port: "sender-port" ":" "integer"
+#line 2698 "dhcp6_parser.yy"
+                                       {
+    ctx.unique("sender-port", ctx.loc2pos(yystack_[2].location));
+    ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("sender-port", i);
+}
+#line 4225 "dhcp6_parser.cc"
+    break;
+
+  case 781: // max_queue_size: "max-queue-size" ":" "integer"
+#line 2704 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("max-queue-size", ctx.loc2pos(yystack_[2].location));
+    ElementPtr i(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("max-queue-size", i);
+}
+#line 4235 "dhcp6_parser.cc"
+    break;
+
+  case 782: // $@120: %empty
+#line 2710 "dhcp6_parser.yy"
+                           {
+    ctx.unique("ncr-protocol", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NCR_PROTOCOL);
+}
+#line 4244 "dhcp6_parser.cc"
+    break;
+
+  case 783: // ncr_protocol: "ncr-protocol" $@120 ":" ncr_protocol_value
+#line 2713 "dhcp6_parser.yy"
+                           {
+    ctx.stack_.back()->set("ncr-protocol", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 4253 "dhcp6_parser.cc"
+    break;
+
+  case 784: // ncr_protocol_value: "UDP"
+#line 2719 "dhcp6_parser.yy"
+        { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("UDP", ctx.loc2pos(yystack_[0].location))); }
+#line 4259 "dhcp6_parser.cc"
+    break;
+
+  case 785: // ncr_protocol_value: "TCP"
+#line 2720 "dhcp6_parser.yy"
+        { yylhs.value.as < ElementPtr > () = ElementPtr(new StringElement("TCP", ctx.loc2pos(yystack_[0].location))); }
+#line 4265 "dhcp6_parser.cc"
+    break;
+
+  case 786: // $@121: %empty
+#line 2723 "dhcp6_parser.yy"
+                       {
+    ctx.unique("ncr-format", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NCR_FORMAT);
+}
+#line 4274 "dhcp6_parser.cc"
+    break;
+
+  case 787: // ncr_format: "ncr-format" $@121 ":" "JSON"
+#line 2726 "dhcp6_parser.yy"
+             {
+    ElementPtr json(new StringElement("JSON", ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("ncr-format", json);
+    ctx.leave();
+}
+#line 4284 "dhcp6_parser.cc"
+    break;
+
+  case 788: // dep_override_no_update: "override-no-update" ":" "boolean"
+#line 2733 "dhcp6_parser.yy"
+                                                         {
+    ctx.unique("override-no-update", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("override-no-update", b);
+}
+#line 4294 "dhcp6_parser.cc"
+    break;
+
+  case 789: // dep_override_client_update: "override-client-update" ":" "boolean"
+#line 2740 "dhcp6_parser.yy"
+                                                                 {
+    ctx.unique("override-client-update", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("override-client-update", b);
+}
+#line 4304 "dhcp6_parser.cc"
+    break;
+
+  case 790: // $@122: %empty
+#line 2747 "dhcp6_parser.yy"
+                                             {
+    ctx.unique("replace-client-name", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.REPLACE_CLIENT_NAME);
+}
+#line 4313 "dhcp6_parser.cc"
+    break;
+
+  case 791: // dep_replace_client_name: "replace-client-name" $@122 ":" ddns_replace_client_name_value
+#line 2750 "dhcp6_parser.yy"
+                                       {
+    ctx.stack_.back()->set("replace-client-name", yystack_[0].value.as < ElementPtr > ());
+    ctx.leave();
+}
+#line 4322 "dhcp6_parser.cc"
+    break;
+
+  case 792: // $@123: %empty
+#line 2756 "dhcp6_parser.yy"
+                                       {
+    ctx.unique("generated-prefix", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4331 "dhcp6_parser.cc"
+    break;
+
+  case 793: // dep_generated_prefix: "generated-prefix" $@123 ":" "constant string"
+#line 2759 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("generated-prefix", s);
+    ctx.leave();
+}
+#line 4341 "dhcp6_parser.cc"
+    break;
+
+  case 794: // $@124: %empty
+#line 2766 "dhcp6_parser.yy"
+                                         {
+    ctx.unique("hostname-char-set", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4350 "dhcp6_parser.cc"
+    break;
+
+  case 795: // dep_hostname_char_set: "hostname-char-set" $@124 ":" "constant string"
+#line 2769 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hostname-char-set", s);
+    ctx.leave();
+}
+#line 4360 "dhcp6_parser.cc"
+    break;
+
+  case 796: // $@125: %empty
+#line 2776 "dhcp6_parser.yy"
+                                                         {
+    ctx.unique("hostname-char-replacement", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4369 "dhcp6_parser.cc"
+    break;
+
+  case 797: // dep_hostname_char_replacement: "hostname-char-replacement" $@125 ":" "constant string"
+#line 2779 "dhcp6_parser.yy"
+               {
+    ElementPtr s(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("hostname-char-replacement", s);
+    ctx.leave();
+}
+#line 4379 "dhcp6_parser.cc"
+    break;
+
+  case 798: // $@126: %empty
+#line 2788 "dhcp6_parser.yy"
+                               {
+    ctx.unique("config-control", ctx.loc2pos(yystack_[0].location));
+    ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("config-control", i);
+    ctx.stack_.push_back(i);
+    ctx.enter(ctx.CONFIG_CONTROL);
+}
+#line 4391 "dhcp6_parser.cc"
+    break;
+
+  case 799: // config_control: "config-control" $@126 ":" "{" config_control_params "}"
+#line 2794 "dhcp6_parser.yy"
+                                                            {
+    // No config control params are required
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4401 "dhcp6_parser.cc"
+    break;
+
+  case 800: // $@127: %empty
+#line 2800 "dhcp6_parser.yy"
+                                   {
+    // Parse the config-control map
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.push_back(m);
+}
+#line 4411 "dhcp6_parser.cc"
+    break;
+
+  case 801: // sub_config_control: "{" $@127 config_control_params "}"
+#line 2804 "dhcp6_parser.yy"
+                                       {
+    // No config_control params are required
+    // parsing completed
+}
+#line 4420 "dhcp6_parser.cc"
+    break;
+
+  case 804: // config_control_params: config_control_params ","
+#line 2812 "dhcp6_parser.yy"
+                                                   {
+                         ctx.warnAboutExtraCommas(yystack_[0].location);
+                         }
+#line 4428 "dhcp6_parser.cc"
+    break;
+
+  case 807: // $@128: %empty
+#line 2822 "dhcp6_parser.yy"
+                                   {
+    ctx.unique("config-databases", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("config-databases", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.CONFIG_DATABASE);
+}
+#line 4440 "dhcp6_parser.cc"
+    break;
+
+  case 808: // config_databases: "config-databases" $@128 ":" "[" database_list "]"
+#line 2828 "dhcp6_parser.yy"
+                                                      {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4449 "dhcp6_parser.cc"
+    break;
+
+  case 809: // config_fetch_wait_time: "config-fetch-wait-time" ":" "integer"
+#line 2833 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("config-fetch-wait-time", ctx.loc2pos(yystack_[2].location));
+    ElementPtr value(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("config-fetch-wait-time", value);
+}
+#line 4459 "dhcp6_parser.cc"
+    break;
+
+  case 810: // $@129: %empty
+#line 2841 "dhcp6_parser.yy"
+                 {
+    ctx.unique("loggers", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("loggers", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.LOGGERS);
+}
+#line 4471 "dhcp6_parser.cc"
+    break;
+
+  case 811: // loggers: "loggers" $@129 ":" "[" loggers_entries "]"
+#line 2847 "dhcp6_parser.yy"
+                                                         {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4480 "dhcp6_parser.cc"
+    break;
+
+  case 814: // loggers_entries: loggers_entries ","
+#line 2856 "dhcp6_parser.yy"
+                                       {
+                   ctx.warnAboutExtraCommas(yystack_[0].location);
+                   }
+#line 4488 "dhcp6_parser.cc"
+    break;
+
+  case 815: // $@130: %empty
+#line 2862 "dhcp6_parser.yy"
+                             {
+    ElementPtr l(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(l);
+    ctx.stack_.push_back(l);
+}
+#line 4498 "dhcp6_parser.cc"
+    break;
+
+  case 816: // logger_entry: "{" $@130 logger_params "}"
+#line 2866 "dhcp6_parser.yy"
+                               {
+    ctx.stack_.pop_back();
+}
+#line 4506 "dhcp6_parser.cc"
+    break;
+
+  case 819: // logger_params: logger_params ","
+#line 2872 "dhcp6_parser.yy"
+                                   {
+                 ctx.warnAboutExtraCommas(yystack_[0].location);
+                 }
+#line 4514 "dhcp6_parser.cc"
+    break;
+
+  case 827: // debuglevel: "debuglevel" ":" "integer"
+#line 2886 "dhcp6_parser.yy"
+                                     {
+    ctx.unique("debuglevel", ctx.loc2pos(yystack_[2].location));
+    ElementPtr dl(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("debuglevel", dl);
+}
+#line 4524 "dhcp6_parser.cc"
+    break;
+
+  case 828: // $@131: %empty
+#line 2892 "dhcp6_parser.yy"
+                   {
+    ctx.unique("severity", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4533 "dhcp6_parser.cc"
+    break;
+
+  case 829: // severity: "severity" $@131 ":" "constant string"
+#line 2895 "dhcp6_parser.yy"
+               {
+    ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("severity", sev);
+    ctx.leave();
+}
+#line 4543 "dhcp6_parser.cc"
+    break;
+
+  case 830: // $@132: %empty
+#line 2901 "dhcp6_parser.yy"
+                                    {
+    ctx.unique("output_options", ctx.loc2pos(yystack_[0].location));
+    ElementPtr l(new ListElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("output_options", l);
+    ctx.stack_.push_back(l);
+    ctx.enter(ctx.OUTPUT_OPTIONS);
+}
+#line 4555 "dhcp6_parser.cc"
+    break;
+
+  case 831: // output_options_list: "output_options" $@132 ":" "[" output_options_list_content "]"
+#line 2907 "dhcp6_parser.yy"
+                                                                    {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4564 "dhcp6_parser.cc"
+    break;
+
+  case 834: // output_options_list_content: output_options_list_content ","
+#line 2914 "dhcp6_parser.yy"
+                                                               {
+                               ctx.warnAboutExtraCommas(yystack_[0].location);
+                               }
+#line 4572 "dhcp6_parser.cc"
+    break;
+
+  case 835: // $@133: %empty
+#line 2919 "dhcp6_parser.yy"
+                             {
+    ElementPtr m(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->add(m);
+    ctx.stack_.push_back(m);
+}
+#line 4582 "dhcp6_parser.cc"
+    break;
+
+  case 836: // output_entry: "{" $@133 output_params_list "}"
+#line 2923 "dhcp6_parser.yy"
+                                    {
+    ctx.stack_.pop_back();
+}
+#line 4590 "dhcp6_parser.cc"
+    break;
+
+  case 839: // output_params_list: output_params_list ","
+#line 2929 "dhcp6_parser.yy"
+                                             {
+                      ctx.warnAboutExtraCommas(yystack_[0].location);
+                      }
+#line 4598 "dhcp6_parser.cc"
+    break;
+
+  case 845: // $@134: %empty
+#line 2941 "dhcp6_parser.yy"
+               {
+    ctx.unique("output", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4607 "dhcp6_parser.cc"
+    break;
+
+  case 846: // output: "output" $@134 ":" "constant string"
+#line 2944 "dhcp6_parser.yy"
+               {
+    ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("output", sev);
+    ctx.leave();
+}
+#line 4617 "dhcp6_parser.cc"
+    break;
+
+  case 847: // flush: "flush" ":" "boolean"
+#line 2950 "dhcp6_parser.yy"
+                           {
+    ctx.unique("flush", ctx.loc2pos(yystack_[2].location));
+    ElementPtr flush(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("flush", flush);
+}
+#line 4627 "dhcp6_parser.cc"
+    break;
+
+  case 848: // maxsize: "maxsize" ":" "integer"
+#line 2956 "dhcp6_parser.yy"
+                               {
+    ctx.unique("maxsize", ctx.loc2pos(yystack_[2].location));
+    ElementPtr maxsize(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("maxsize", maxsize);
+}
+#line 4637 "dhcp6_parser.cc"
+    break;
+
+  case 849: // maxver: "maxver" ":" "integer"
+#line 2962 "dhcp6_parser.yy"
+                             {
+    ctx.unique("maxver", ctx.loc2pos(yystack_[2].location));
+    ElementPtr maxver(new IntElement(yystack_[0].value.as < int64_t > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("maxver", maxver);
+}
+#line 4647 "dhcp6_parser.cc"
+    break;
+
+  case 850: // $@135: %empty
+#line 2968 "dhcp6_parser.yy"
+                 {
+    ctx.unique("pattern", ctx.loc2pos(yystack_[0].location));
+    ctx.enter(ctx.NO_KEYWORD);
+}
+#line 4656 "dhcp6_parser.cc"
+    break;
+
+  case 851: // pattern: "pattern" $@135 ":" "constant string"
+#line 2971 "dhcp6_parser.yy"
+               {
+    ElementPtr sev(new StringElement(yystack_[0].value.as < std::string > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("pattern", sev);
+    ctx.leave();
+}
+#line 4666 "dhcp6_parser.cc"
+    break;
+
+  case 852: // $@136: %empty
+#line 2977 "dhcp6_parser.yy"
+                             {
+    ctx.unique("compatibility", ctx.loc2pos(yystack_[0].location));
+    ElementPtr i(new MapElement(ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("compatibility", i);
+    ctx.stack_.push_back(i);
+    ctx.enter(ctx.COMPATIBILITY);
+}
+#line 4678 "dhcp6_parser.cc"
+    break;
+
+  case 853: // compatibility: "compatibility" $@136 ":" "{" compatibility_params "}"
+#line 2983 "dhcp6_parser.yy"
+                                                           {
+    ctx.stack_.pop_back();
+    ctx.leave();
+}
+#line 4687 "dhcp6_parser.cc"
+    break;
+
+  case 856: // compatibility_params: compatibility_params ","
+#line 2990 "dhcp6_parser.yy"
+                                                 {
+                        ctx.warnAboutExtraCommas(yystack_[0].location);
+                        }
+#line 4695 "dhcp6_parser.cc"
+    break;
+
+  case 859: // lenient_option_parsing: "lenient-option-parsing" ":" "boolean"
+#line 2999 "dhcp6_parser.yy"
+                                                             {
+    ctx.unique("lenient-option-parsing", ctx.loc2pos(yystack_[2].location));
+    ElementPtr b(new BoolElement(yystack_[0].value.as < bool > (), ctx.loc2pos(yystack_[0].location)));
+    ctx.stack_.back()->set("lenient-option-parsing", b);
+}
+#line 4705 "dhcp6_parser.cc"
+    break;
+
+
+#line 4709 "dhcp6_parser.cc"
+
+            default:
+              break;
+            }
+        }
+#if YY_EXCEPTIONS
+      catch (const syntax_error& yyexc)
+        {
+          YYCDEBUG << "Caught exception: " << yyexc.what() << '\n';
+          error (yyexc);
+          YYERROR;
+        }
+#endif // YY_EXCEPTIONS
+      YY_SYMBOL_PRINT ("-> $$ =", yylhs);
+      yypop_ (yylen);
+      yylen = 0;
+
+      // Shift the result of the reduction.
+      yypush_ (YY_NULLPTR, YY_MOVE (yylhs));
+    }
+    goto yynewstate;
+
+
+  /*--------------------------------------.
+  | yyerrlab -- here on detecting error.  |
+  `--------------------------------------*/
+  yyerrlab:
+    // If not already recovering from an error, report this error.
+    if (!yyerrstatus_)
+      {
+        ++yynerrs_;
+        context yyctx (*this, yyla);
+        std::string msg = yysyntax_error_ (yyctx);
+        error (yyla.location, YY_MOVE (msg));
+      }
+
+
+    yyerror_range[1].location = yyla.location;
+    if (yyerrstatus_ == 3)
+      {
+        /* If just tried and failed to reuse lookahead token after an
+           error, discard it.  */
+
+        // Return failure if at end of input.
+        if (yyla.kind () == symbol_kind::S_YYEOF)
+          YYABORT;
+        else if (!yyla.empty ())
+          {
+            yy_destroy_ ("Error: discarding", yyla);
+            yyla.clear ();
+          }
+      }
+
+    // Else will try to reuse lookahead token after shifting the error token.
+    goto yyerrlab1;
+
+
+  /*---------------------------------------------------.
+  | yyerrorlab -- error raised explicitly by YYERROR.  |
+  `---------------------------------------------------*/
+  yyerrorlab:
+    /* Pacify compilers when the user code never invokes YYERROR and
+       the label yyerrorlab therefore never appears in user code.  */
+    if (false)
+      YYERROR;
+
+    /* Do not reclaim the symbols of the rule whose action triggered
+       this YYERROR.  */
+    yypop_ (yylen);
+    yylen = 0;
+    YY_STACK_PRINT ();
+    goto yyerrlab1;
+
+
+  /*-------------------------------------------------------------.
+  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
+  `-------------------------------------------------------------*/
+  yyerrlab1:
+    yyerrstatus_ = 3;   // Each real token shifted decrements this.
+    // Pop stack until we find a state that shifts the error token.
+    for (;;)
+      {
+        yyn = yypact_[+yystack_[0].state];
+        if (!yy_pact_value_is_default_ (yyn))
+          {
+            yyn += symbol_kind::S_YYerror;
+            if (0 <= yyn && yyn <= yylast_
+                && yycheck_[yyn] == symbol_kind::S_YYerror)
+              {
+                yyn = yytable_[yyn];
+                if (0 < yyn)
+                  break;
+              }
+          }
+
+        // Pop the current state because it cannot handle the error token.
+        if (yystack_.size () == 1)
+          YYABORT;
+
+        yyerror_range[1].location = yystack_[0].location;
+        yy_destroy_ ("Error: popping", yystack_[0]);
+        yypop_ ();
+        YY_STACK_PRINT ();
+      }
+    {
+      stack_symbol_type error_token;
+
+      yyerror_range[2].location = yyla.location;
+      YYLLOC_DEFAULT (error_token.location, yyerror_range, 2);
+
+      // Shift the error token.
+      error_token.state = state_type (yyn);
+      yypush_ ("Shifting", YY_MOVE (error_token));
+    }
+    goto yynewstate;
+
+
+  /*-------------------------------------.
+  | yyacceptlab -- YYACCEPT comes here.  |
+  `-------------------------------------*/
+  yyacceptlab:
+    yyresult = 0;
+    goto yyreturn;
+
+
+  /*-----------------------------------.
+  | yyabortlab -- YYABORT comes here.  |
+  `-----------------------------------*/
+  yyabortlab:
+    yyresult = 1;
+    goto yyreturn;
+
+
+  /*-----------------------------------------------------.
+  | yyreturn -- parsing is finished, return the result.  |
+  `-----------------------------------------------------*/
+  yyreturn:
+    if (!yyla.empty ())
+      yy_destroy_ ("Cleanup: discarding lookahead", yyla);
+
+    /* Do not reclaim the symbols of the rule whose action triggered
+       this YYABORT or YYACCEPT.  */
+    yypop_ (yylen);
+    YY_STACK_PRINT ();
+    while (1 < yystack_.size ())
+      {
+        yy_destroy_ ("Cleanup: popping", yystack_[0]);
+        yypop_ ();
+      }
+
+    return yyresult;
+  }
+#if YY_EXCEPTIONS
+    catch (...)
+      {
+        YYCDEBUG << "Exception caught: cleaning lookahead and stack\n";
+        // Do not try to display the values of the reclaimed symbols,
+        // as their printers might throw an exception.
+        if (!yyla.empty ())
+          yy_destroy_ (YY_NULLPTR, yyla);
+
+        while (1 < yystack_.size ())
+          {
+            yy_destroy_ (YY_NULLPTR, yystack_[0]);
+            yypop_ ();
+          }
+        throw;
+      }
+#endif // YY_EXCEPTIONS
+  }
+
+  void
+  Dhcp6Parser::error (const syntax_error& yyexc)
+  {
+    error (yyexc.location, yyexc.what ());
+  }
+
+  /* Return YYSTR after stripping away unnecessary quotes and
+     backslashes, so that it's suitable for yyerror.  The heuristic is
+     that double-quoting is unnecessary unless the string contains an
+     apostrophe, a comma, or backslash (other than backslash-backslash).
+     YYSTR is taken from yytname.  */
+  std::string
+  Dhcp6Parser::yytnamerr_ (const char *yystr)
+  {
+    if (*yystr == '"')
+      {
+        std::string yyr;
+        char const *yyp = yystr;
+
+        for (;;)
+          switch (*++yyp)
+            {
+            case '\'':
+            case ',':
+              goto do_not_strip_quotes;
+
+            case '\\':
+              if (*++yyp != '\\')
+                goto do_not_strip_quotes;
+              else
+                goto append;
+
+            append:
+            default:
+              yyr += *yyp;
+              break;
+
+            case '"':
+              return yyr;
+            }
+      do_not_strip_quotes: ;
+      }
+
+    return yystr;
+  }
+
+  std::string
+  Dhcp6Parser::symbol_name (symbol_kind_type yysymbol)
+  {
+    return yytnamerr_ (yytname_[yysymbol]);
+  }
+
+
+
+  // Dhcp6Parser::context.
+  Dhcp6Parser::context::context (const Dhcp6Parser& yyparser, const symbol_type& yyla)
+    : yyparser_ (yyparser)
+    , yyla_ (yyla)
+  {}
+
+  int
+  Dhcp6Parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const
+  {
+    // Actual number of expected tokens
+    int yycount = 0;
+
+    const int yyn = yypact_[+yyparser_.yystack_[0].state];
+    if (!yy_pact_value_is_default_ (yyn))
+      {
+        /* Start YYX at -YYN if negative to avoid negative indexes in
+           YYCHECK.  In other words, skip the first -YYN actions for
+           this state because they are default actions.  */
+        const int yyxbegin = yyn < 0 ? -yyn : 0;
+        // Stay within bounds of both yycheck and yytname.
+        const int yychecklim = yylast_ - yyn + 1;
+        const int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+        for (int yyx = yyxbegin; yyx < yyxend; ++yyx)
+          if (yycheck_[yyx + yyn] == yyx && yyx != symbol_kind::S_YYerror
+              && !yy_table_value_is_error_ (yytable_[yyx + yyn]))
+            {
+              if (!yyarg)
+                ++yycount;
+              else if (yycount == yyargn)
+                return 0;
+              else
+                yyarg[yycount++] = YY_CAST (symbol_kind_type, yyx);
+            }
+      }
+
+    if (yyarg && yycount == 0 && 0 < yyargn)
+      yyarg[0] = symbol_kind::S_YYEMPTY;
+    return yycount;
+  }
+
+
+
+
+
+
+  int
+  Dhcp6Parser::yy_syntax_error_arguments_ (const context& yyctx,
+                                                 symbol_kind_type yyarg[], int yyargn) const
+  {
+    /* There are many possibilities here to consider:
+       - If this state is a consistent state with a default action, then
+         the only way this function was invoked is if the default action
+         is an error action.  In that case, don't check for expected
+         tokens because there are none.
+       - The only way there can be no lookahead present (in yyla) is
+         if this state is a consistent state with a default action.
+         Thus, detecting the absence of a lookahead is sufficient to
+         determine that there is no unexpected or expected token to
+         report.  In that case, just report a simple "syntax error".
+       - Don't assume there isn't a lookahead just because this state is
+         a consistent state with a default action.  There might have
+         been a previous inconsistent state, consistent state with a
+         non-default action, or user semantic action that manipulated
+         yyla.  (However, yyla is currently not documented for users.)
+       - Of course, the expected token list depends on states to have
+         correct lookahead information, and it depends on the parser not
+         to perform extra reductions after fetching a lookahead from the
+         scanner and before detecting a syntax error.  Thus, state merging
+         (from LALR or IELR) and default reductions corrupt the expected
+         token list.  However, the list is correct for canonical LR with
+         one exception: it will still contain any token that will not be
+         accepted due to an error action in a later state.
+    */
+
+    if (!yyctx.lookahead ().empty ())
+      {
+        if (yyarg)
+          yyarg[0] = yyctx.token ();
+        int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1);
+        return yyn + 1;
+      }
+    return 0;
+  }
+
+  // Generate an error message.
+  std::string
+  Dhcp6Parser::yysyntax_error_ (const context& yyctx) const
+  {
+    // Its maximum.
+    enum { YYARGS_MAX = 5 };
+    // Arguments of yyformat.
+    symbol_kind_type yyarg[YYARGS_MAX];
+    int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX);
+
+    char const* yyformat = YY_NULLPTR;
+    switch (yycount)
+      {
+#define YYCASE_(N, S)                         \
+        case N:                               \
+          yyformat = S;                       \
+        break
+      default: // Avoid compiler warnings.
+        YYCASE_ (0, YY_("syntax error"));
+        YYCASE_ (1, YY_("syntax error, unexpected %s"));
+        YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s"));
+        YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+        YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+        YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+#undef YYCASE_
+      }
+
+    std::string yyres;
+    // Argument number.
+    std::ptrdiff_t yyi = 0;
+    for (char const* yyp = yyformat; *yyp; ++yyp)
+      if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount)
+        {
+          yyres += symbol_name (yyarg[yyi++]);
+          ++yyp;
+        }
+      else
+        yyres += *yyp;
+    return yyres;
+  }
+
+
+  const short Dhcp6Parser::yypact_ninf_ = -996;
+
+  const signed char Dhcp6Parser::yytable_ninf_ = -1;
+
+  const short
+  Dhcp6Parser::yypact_[] =
+  {
+     437,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,    36,    30,    93,    94,   106,
+     108,   137,   155,   171,   173,   180,   182,   192,   193,   199,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,    30,  -166,
+     130,   160,    78,   668,    42,   296,    71,    -2,    81,   -25,
+     -90,   451,    35,  -996,   244,   248,   260,   257,   297,  -996,
+      65,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   306,   328,
+     329,   335,   349,   359,   362,   369,   370,   377,   379,   389,
+     397,   398,  -996,   399,   416,   434,   436,   439,  -996,  -996,
+    -996,   440,   441,   442,  -996,  -996,  -996,   443,  -996,  -996,
+    -996,  -996,   444,   445,   446,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,   447,  -996,  -996,  -996,  -996,  -996,
+    -996,   448,   449,   452,  -996,  -996,   455,  -996,    96,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,   456,   457,   459,   463,  -996,
+     100,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,   464,   465,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,   113,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   123,
+    -996,  -996,  -996,  -996,  -996,   467,  -996,   468,   471,  -996,
+    -996,  -996,  -996,  -996,  -996,   133,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,   323,   438,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,   357,  -996,  -996,   472,  -996,  -996,  -996,
+     473,  -996,  -996,   470,   476,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   477,   479,
+    -996,  -996,  -996,  -996,   478,   482,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   176,  -996,
+    -996,  -996,   483,  -996,  -996,   484,  -996,   487,   488,  -996,
+    -996,   499,   500,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     236,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   503,   246,
+    -996,  -996,  -996,  -996,    30,    30,  -996,   245,   504,  -996,
+    -996,   508,   510,   513,   514,   516,   517,   315,   316,   317,
+     319,   320,   324,   325,   331,   321,   312,   326,   338,   340,
+     341,   518,   342,   344,   348,   351,   352,   536,   550,   552,
+     354,   356,   358,   553,   556,   566,   365,   568,   569,   571,
+     574,   373,   375,   376,   578,   579,   581,   586,   588,   589,
+     592,   594,   595,   393,   596,   598,   601,   602,   603,   605,
+     412,   415,   417,   620,   622,  -996,   160,  -996,   623,   435,
+     450,   418,   453,    78,  -996,   643,   645,   646,   647,   649,
+     454,   460,   650,   652,   653,   668,  -996,   654,    42,  -996,
+     655,   458,   656,   461,   466,   296,  -996,   658,   662,   663,
+     664,   666,   670,   671,  -996,    71,  -996,   672,   674,   469,
+     675,   677,   678,   474,  -996,    81,   679,   480,   481,  -996,
+     -25,   680,   681,   -73,  -996,   485,   682,   687,   486,   691,
+     489,   490,   695,   698,   496,   497,   699,   707,   709,   724,
+     451,  -996,   725,   519,    35,  -996,  -996,  -996,   727,   734,
+     532,   737,   738,   739,   745,   748,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     544,  -996,  -996,  -996,  -996,  -996,   -95,   546,   548,  -996,
+    -996,  -996,   754,   755,   756,  -996,   766,   765,   563,   327,
+    -996,  -996,  -996,   769,   773,   774,   775,   776,   778,   780,
+     779,   782,  -996,   783,   784,   785,   786,   570,   584,  -996,
+    -996,  -996,   791,   790,  -996,   793,  -996,  -996,  -996,  -996,
+    -996,   794,   795,   591,   593,   607,  -996,  -996,   793,   608,
+     812,  -996,   610,  -996,   621,  -996,   624,  -996,  -996,  -996,
+     793,   793,   793,   625,   626,   627,   628,  -996,   629,   630,
+    -996,   631,   632,   633,  -996,  -996,   634,  -996,  -996,  -996,
+     635,   765,  -996,  -996,   636,   637,  -996,   640,  -996,  -996,
+     -50,   587,  -996,  -996,   -95,   641,   644,   651,  -996,   797,
+    -996,  -996,    30,   160,  -996,    35,    78,   292,   292,   850,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   853,
+     855,   856,   860,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,   -91,    30,   313,   758,   861,   862,   863,   273,   252,
+     152,   -20,    -5,   451,  -996,  -996,   864,  -145,  -996,  -996,
+     867,   868,  -996,  -996,  -996,  -996,  -996,   -19,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,   850,  -996,   250,
+     271,   274,  -996,  -996,  -996,  -996,   873,   875,   876,   877,
+     878,   879,   881,  -996,   882,  -996,  -996,  -996,  -996,  -996,
+     275,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     290,  -996,   883,   884,  -996,  -996,   885,   887,  -996,  -996,
+     886,   890,  -996,  -996,   888,   892,  -996,  -996,   891,   893,
+    -996,  -996,  -996,   185,  -996,  -996,  -996,   894,  -996,  -996,
+    -996,   284,  -996,  -996,  -996,  -996,   301,  -996,  -996,  -996,
+     291,  -996,  -996,   895,   896,  -996,  -996,   897,   899,  -996,
+     900,   901,   902,   903,   904,   905,   303,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,   906,   907,   908,  -996,
+    -996,  -996,  -996,   310,  -996,  -996,  -996,  -996,  -996,  -996,
+     909,   910,   911,  -996,   343,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,   347,  -996,  -996,  -996,
+     912,  -996,   913,  -996,  -996,  -996,   361,  -996,  -996,  -996,
+    -996,  -996,   364,  -996,   311,  -996,   914,  -996,   372,  -996,
+    -996,   688,  -996,   915,   916,  -996,  -996,   917,   919,  -996,
+    -996,  -996,   880,  -996,   918,  -996,  -996,  -996,   921,   922,
+     923,   924,   718,   717,   720,   719,   722,   723,   728,   931,
+     730,   932,   938,   940,   941,   292,  -996,  -996,   292,  -996,
+     850,   668,  -996,   853,    81,  -996,   855,   -25,  -996,   856,
+     757,  -996,   860,   -91,  -996,  -996,   313,  -996,   943,   758,
+    -996,   309,   861,  -996,    71,  -996,   862,   -90,  -996,   863,
+     743,   744,   746,   747,   753,   759,   273,  -996,   944,   967,
+     762,   763,   767,   252,  -996,   788,   799,   800,   152,  -996,
+     991,   992,   -20,  -996,   801,  1014,   809,  1017,    -5,  -996,
+    -996,   190,   864,  -996,   816,  -145,  -996,  -996,  1027,  1031,
+      42,  -996,   867,   296,  -996,   868,  1033,  -996,  -996,   129,
+     710,   832,   845,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     197,  -996,   852,   889,   898,   920,  -996,   374,  -996,   391,
+    -996,  1070,  -996,  1077,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,   410,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     925,  -996,  -996,  1084,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  1083,  1091,  -996,  -996,  -996,
+    -996,  -996,  1088,  -996,   411,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,    28,   926,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,   927,   928,  -996,  -996,   929,  -996,    30,
+    -996,  -996,  1093,  -996,  -996,  -996,  -996,  -996,   413,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,   930,   414,  -996,
+     420,  -996,   933,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,   757,  -996,  -996,  1094,   934,  -996,   309,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    1096,   935,  1097,   190,  -996,  -996,  -996,  -996,  -996,  -996,
+     939,  -996,  -996,  1098,  -996,   942,  -996,  -996,  1095,  -996,
+    -996,   346,  -996,    11,  1095,  -996,  -996,  1100,  1101,  1102,
+    -996,   426,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  1103,
+     937,   946,   948,  1105,    11,  -996,   950,  -996,  -996,  -996,
+     951,  -996,  -996,  -996
+  };
+
+  const short
+  Dhcp6Parser::yydefact_[] =
+  {
+       0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
+      20,    22,    24,    26,    28,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       1,    46,    38,    34,    33,    30,    31,    32,    37,     3,
+      35,    36,    61,     5,    67,     7,   184,     9,   362,    11,
+     565,    13,   592,    15,   624,    17,   485,    19,   494,    21,
+     533,    23,   324,    25,   749,    27,   800,    29,    48,    41,
+       0,     0,     0,     0,     0,     0,   626,     0,   496,   535,
+       0,     0,     0,    50,     0,    49,     0,     0,    42,    63,
+       0,    65,   137,   798,   182,   203,   205,   207,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   176,     0,     0,     0,     0,     0,   156,   163,
+     165,     0,     0,     0,   353,   483,   524,     0,   431,   579,
+     581,   423,     0,     0,     0,   280,   299,   289,   272,   662,
+     615,   315,   336,   691,     0,   301,   716,   730,   747,   169,
+     171,     0,     0,     0,   810,   852,     0,   136,     0,    69,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,   111,
+     112,   113,   114,   115,    81,   119,   120,   121,   122,   123,
+     124,   125,   126,   117,   118,   127,   128,   129,   106,   135,
+     131,   132,   133,    84,    85,    86,    87,   103,    88,    90,
+      89,   130,    94,    95,    82,   108,   109,   110,   107,    83,
+      92,    93,   101,   102,   104,    91,    96,    97,    98,    99,
+     100,   105,   116,   134,   197,     0,     0,     0,     0,   196,
+       0,   186,   189,   190,   191,   192,   193,   194,   195,   556,
+     583,   410,   412,   414,     0,     0,   418,   416,   656,   409,
+     367,   368,   369,   370,   371,   372,   373,   374,   393,   394,
+     395,   396,   397,   400,   401,   402,   403,   404,   405,   406,
+     407,   398,   399,   408,     0,   364,   378,   379,   380,   383,
+     384,   387,   388,   389,   386,   381,   382,   375,   376,   391,
+     392,   377,   385,   390,   577,   576,   572,   573,   571,     0,
+     567,   570,   574,   575,   608,     0,   611,     0,     0,   607,
+     601,   602,   600,   605,   606,     0,   594,   597,   598,   603,
+     604,   599,   654,   642,   644,   646,   648,   650,   652,   641,
+     638,   639,   640,     0,   627,   628,   633,   634,   631,   635,
+     636,   637,   632,     0,   514,   250,     0,   518,   516,   521,
+       0,   510,   511,     0,   497,   498,   501,   513,   502,   503,
+     504,   520,   505,   506,   507,   508,   509,   550,     0,     0,
+     548,   549,   552,   553,     0,   536,   537,   540,   541,   542,
+     543,   544,   545,   546,   547,   332,   334,   329,     0,   326,
+     330,   331,     0,   773,   775,     0,   778,     0,     0,   782,
+     786,     0,     0,   790,   792,   794,   796,   771,   769,   770,
+       0,   751,   754,   766,   755,   756,   757,   758,   759,   760,
+     761,   762,   763,   764,   765,   767,   768,   807,     0,     0,
+     802,   805,   806,    47,    52,     0,    39,    45,     0,    66,
+      62,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,    60,    71,    68,     0,     0,
+       0,     0,     0,   188,   185,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   366,   363,     0,   569,   566,
+       0,     0,     0,     0,     0,   596,   593,     0,     0,     0,
+       0,     0,     0,     0,   625,   630,   486,     0,     0,     0,
+       0,     0,     0,     0,   495,   500,     0,     0,     0,   534,
+     539,     0,     0,   328,   325,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     753,   750,     0,     0,   804,   801,    51,    43,     0,     0,
+       0,     0,     0,     0,     0,     0,   139,   140,   141,   142,
+     143,   144,   145,   146,   147,   148,   149,   150,   151,   152,
+       0,   174,   175,   153,   154,   155,     0,     0,     0,   167,
+     168,   173,     0,     0,     0,   178,     0,     0,     0,     0,
+     420,   421,   422,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   715,     0,     0,     0,     0,     0,     0,   179,
+     180,   181,     0,     0,    70,     0,   199,   200,   201,   202,
+     187,     0,     0,     0,     0,     0,   429,   430,     0,     0,
+       0,   365,     0,   568,     0,   610,     0,   613,   614,   595,
+       0,     0,     0,     0,     0,     0,     0,   629,     0,     0,
+     512,     0,     0,     0,   523,   499,     0,   554,   555,   538,
+       0,     0,   327,   772,     0,     0,   777,     0,   780,   781,
+       0,     0,   788,   789,     0,     0,     0,     0,   752,     0,
+     809,   803,     0,     0,   138,     0,     0,     0,     0,   209,
+     177,   158,   159,   160,   161,   162,   157,   164,   166,   355,
+     487,   526,   433,    40,   580,   582,   425,   426,   427,   428,
+     424,     0,    48,     0,     0,     0,   617,   317,     0,     0,
+       0,     0,     0,     0,   170,   172,     0,     0,    53,   198,
+     558,   585,   411,   413,   415,   419,   417,     0,   578,   609,
+     612,   655,   643,   645,   647,   649,   651,   653,   515,   251,
+     519,   517,   522,   551,   333,   335,   774,   776,   779,   784,
+     785,   783,   787,   791,   793,   795,   797,   209,    44,     0,
+       0,     0,   238,   243,   245,   247,     0,     0,     0,     0,
+       0,     0,     0,   257,     0,   264,   266,   268,   270,   237,
+       0,   216,   219,   220,   221,   222,   223,   224,   225,   226,
+     227,   228,   230,   231,   232,   229,   233,   234,   235,   236,
+       0,   214,     0,   210,   211,   360,     0,   356,   357,   492,
+       0,   488,   489,   531,     0,   527,   528,   438,     0,   434,
+     435,   287,   288,     0,   282,   285,   286,     0,   297,   298,
+     294,     0,   291,   295,   296,   278,     0,   274,   277,   667,
+       0,   664,   622,     0,   618,   619,   322,     0,   318,   319,
+       0,     0,     0,     0,     0,     0,     0,   338,   341,   342,
+     343,   344,   345,   346,   705,   711,     0,     0,     0,   704,
+     701,   702,   703,     0,   693,   696,   699,   697,   698,   700,
+       0,     0,     0,   311,     0,   303,   306,   307,   308,   309,
+     310,   726,   728,   725,   723,   724,     0,   718,   721,   722,
+       0,   742,     0,   745,   738,   739,     0,   732,   735,   736,
+     737,   740,     0,   815,     0,   812,     0,   858,     0,   854,
+     857,    55,   563,     0,   559,   560,   590,     0,   586,   587,
+     660,   659,     0,   658,     0,    64,   799,   183,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   218,   204,   206,     0,   208,
+     213,     0,   354,   359,   496,   484,   491,   535,   525,   530,
+       0,   432,   437,   284,   281,   300,   293,   290,     0,   276,
+     273,   669,   666,   663,   626,   616,   621,     0,   316,   321,
+       0,     0,     0,     0,     0,     0,   340,   337,     0,     0,
+       0,     0,     0,   695,   692,     0,     0,     0,   305,   302,
+       0,     0,   720,   717,     0,     0,     0,     0,   734,   731,
+     748,     0,   814,   811,     0,   856,   853,    57,     0,    56,
+       0,   557,   562,     0,   584,   589,     0,   657,   808,     0,
+       0,     0,     0,   249,   252,   253,   254,   255,   263,   256,
+       0,   262,     0,     0,     0,     0,   217,     0,   212,     0,
+     358,     0,   490,     0,   529,   482,   457,   458,   459,   461,
+     462,   463,   447,   448,   466,   467,   468,   469,   470,   473,
+     474,   475,   476,   477,   478,   479,   480,   471,   472,   481,
+     443,   444,   445,   446,   455,   456,   452,   453,   454,   451,
+     460,     0,   440,   449,   464,   465,   450,   436,   283,   292,
+       0,   275,   688,     0,   686,   680,   681,   682,   683,   684,
+     685,   687,   677,   678,   679,     0,   670,   671,   674,   675,
+     676,   665,     0,   620,     0,   320,   347,   348,   349,   350,
+     351,   352,   339,     0,     0,   710,   713,   714,   694,   312,
+     313,   314,   304,     0,     0,   719,   741,     0,   744,     0,
+     733,   830,     0,   828,   826,   820,   824,   825,     0,   817,
+     822,   823,   821,   813,   859,   855,    54,    59,     0,   561,
+       0,   588,     0,   240,   241,   242,   239,   244,   246,   248,
+     259,   260,   261,   258,   265,   267,   269,   271,   215,   361,
+     493,   532,   442,   439,   279,     0,     0,   668,   673,   623,
+     323,   707,   708,   709,   706,   712,   727,   729,   743,   746,
+       0,     0,     0,   819,   816,    58,   564,   591,   661,   441,
+       0,   690,   672,     0,   827,     0,   818,   689,     0,   829,
+     835,     0,   832,     0,   834,   831,   845,     0,     0,     0,
+     850,     0,   837,   840,   841,   842,   843,   844,   833,     0,
+       0,     0,     0,     0,   839,   836,     0,   847,   848,   849,
+       0,   838,   846,   851
+  };
+
+  const short
+  Dhcp6Parser::yypgoto_[] =
+  {
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,   -10,  -996,  -589,  -996,
+     409,  -996,  -996,  -996,  -996,   360,  -996,  -594,  -996,  -996,
+    -996,   -71,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   388,
+     609,  -996,  -996,   -43,   -14,    12,    16,    20,    33,   -59,
+     -31,   -30,   -28,   -27,   -26,    19,  -996,    34,    37,    38,
+      41,  -996,   400,    49,  -996,    52,  -996,    54,    55,    56,
+    -996,    59,  -996,    62,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,   387,   604,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     314,  -996,   109,  -996,  -712,   111,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,   -45,  -996,  -748,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,    89,
+    -996,  -996,  -996,  -996,  -996,    97,  -731,  -996,  -996,  -996,
+    -996,    98,  -996,  -996,  -996,  -996,  -996,  -996,  -996,    64,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,    84,  -996,  -996,
+    -996,    88,   564,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+      80,  -996,  -996,  -996,  -996,  -996,  -996,  -995,  -996,  -996,
+    -996,   115,  -996,  -996,  -996,   118,   606,  -996,  -996,  -993,
+    -996,  -992,  -996,    73,  -996,    75,  -996,    66,    69,    70,
+      72,  -996,  -996,  -996,  -991,  -996,  -996,  -996,  -996,   110,
+    -996,  -996,  -119,  1057,  -996,  -996,  -996,  -996,  -996,   125,
+    -996,  -996,  -996,   128,  -996,   590,  -996,   -67,  -996,  -996,
+    -996,  -996,  -996,   -64,  -996,  -996,  -996,  -996,  -996,     4,
+    -996,  -996,  -996,   132,  -996,  -996,  -996,   127,  -996,   611,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,    82,  -996,  -996,  -996,    68,   638,  -996,  -996,   -55,
+    -996,   -12,  -996,  -996,  -996,  -996,  -996,    77,  -996,  -996,
+    -996,    85,   619,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     -60,  -996,  -996,  -996,   131,  -996,  -996,  -996,   135,  -996,
+     618,   395,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -989,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,   138,  -996,  -996,  -996,   -93,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,   120,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   112,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,   107,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,   419,   597,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,   475,   599,
+    -996,  -996,  -996,  -996,  -996,  -996,   104,  -996,  -996,   -94,
+    -996,  -996,  -996,  -996,  -996,  -996,  -116,  -996,  -996,  -134,
+    -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,  -996,
+     114,  -996
+  };
+
+  const short
+  Dhcp6Parser::yydefgoto_[] =
+  {
+       0,    15,    16,    17,    18,    19,    20,    21,    22,    23,
+      24,    25,    26,    27,    28,    29,    83,    39,    40,    69,
+     744,    87,    88,    41,    68,    84,    85,   769,   971,  1078,
+    1079,   829,    43,    70,    90,   438,    91,    45,    71,   158,
+     159,   160,   441,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   173,   174,   175,   176,   177,
+     178,   467,   736,   179,   468,   180,   469,   181,   182,   183,
+     498,   184,   499,   185,   186,   187,   188,   461,   189,   190,
+     191,   192,   193,   443,    47,    72,   230,   231,   232,   508,
+     233,   234,   235,   236,   194,   444,   195,   445,   196,   446,
+     852,   853,   854,  1008,   830,   831,   832,   988,  1236,   833,
+     989,   834,   990,   835,   991,   836,   837,   548,   838,   839,
+     840,   841,   842,   843,   999,  1243,   844,   845,   846,  1001,
+     847,  1002,   848,  1003,   849,  1004,   197,   487,   886,   887,
+     888,  1028,   198,   484,   873,   874,   875,   876,   199,   486,
+     881,   882,   883,   884,   200,   485,   201,   494,   934,   935,
+     936,   937,   938,   202,   490,   897,   898,   899,  1037,    63,
+      80,   388,   389,   390,   561,   391,   562,   203,   491,   906,
+     907,   908,   909,   910,   911,   912,   913,   204,   473,   856,
+     857,   858,  1011,    49,    73,   274,   275,   276,   517,   277,
+     518,   278,   519,   279,   523,   280,   522,   205,   206,   207,
+     208,   480,   750,   285,   286,   209,   477,   868,   869,   870,
+    1020,  1151,  1152,   210,   474,    57,    77,   860,   861,   862,
+    1014,    59,    78,   353,   354,   355,   356,   357,   358,   359,
+     547,   360,   551,   361,   550,   362,   363,   552,   364,   211,
+     475,   864,   865,   866,  1017,    61,    79,   374,   375,   376,
+     377,   378,   556,   379,   380,   381,   382,   288,   515,   973,
+     974,   975,  1080,    51,    74,   299,   300,   301,   527,   212,
+     478,   213,   479,   291,   516,   977,   978,   979,  1083,    53,
+      75,   315,   316,   317,   530,   318,   319,   532,   320,   321,
+     214,   489,   893,   894,   895,  1034,    55,    76,   333,   334,
+     335,   336,   538,   337,   539,   338,   540,   339,   541,   340,
+     542,   341,   543,   342,   537,   293,   524,   982,   983,  1086,
+     215,   488,   890,   891,  1031,  1175,  1176,  1177,  1178,  1179,
+    1255,  1180,   216,   492,   923,   924,   925,  1048,  1264,   926,
+     927,  1049,   928,   929,   217,   218,   495,   946,   947,   948,
+    1060,   949,  1061,   219,   496,   956,   957,   958,   959,  1065,
+     960,   961,  1067,   220,   497,    65,    81,   410,   411,   412,
+     413,   566,   414,   567,   415,   416,   569,   417,   418,   419,
+     572,   801,   420,   573,   421,   422,   423,   576,   424,   577,
+     425,   578,   426,   579,   221,   442,    67,    82,   429,   430,
+     431,   582,   432,   222,   503,   964,   965,  1071,  1218,  1219,
+    1220,  1221,  1272,  1222,  1270,  1291,  1292,  1293,  1301,  1302,
+    1303,  1309,  1304,  1305,  1306,  1307,  1313,   223,   504,   968,
+     969,   970
+  };
+
+  const short
+  Dhcp6Parser::yytable_[] =
+  {
+     157,   229,   249,   295,   309,   329,    38,   351,   370,   387,
+     407,   920,   372,   292,   256,   373,   850,   237,   289,   302,
+     313,   331,   880,   365,   383,  1141,   408,  1142,  1143,  1150,
+     250,  1156,   871,   352,   371,    31,    30,    32,   743,    33,
+     385,   386,   257,   258,    86,   259,   260,   261,   427,   428,
+     966,   345,   367,   346,   347,   368,   369,   385,   386,   251,
+     238,   290,   303,   314,   332,   156,   366,   384,   439,   409,
+     129,   130,   125,   440,   775,   129,   130,   287,   298,   312,
+     330,   731,   732,   733,   734,   252,   781,   782,   783,   253,
+     129,   130,   262,   254,   224,   225,   226,   227,   228,   506,
+      42,    44,   323,   513,   507,   344,   255,   263,   514,   980,
+     264,   265,   743,    46,   266,    48,   525,   126,   735,   872,
+     156,   526,   267,   799,   800,   268,   528,   269,   270,   271,
+     294,   529,   272,   941,   942,   273,   535,   129,   130,   281,
+      89,   536,   282,   283,    50,   284,   126,   296,   310,   297,
+     311,   950,   951,   952,  1233,  1234,  1235,   345,   246,   346,
+     347,   247,    52,   348,   349,   350,   129,   130,  1261,  1262,
+    1263,    92,    93,   129,   130,    94,   129,   130,    54,   563,
+      56,    95,    96,    97,   564,   156,   322,    58,  1023,    60,
+     156,  1024,   323,   324,   325,   326,   327,   328,  1296,    62,
+      64,  1297,  1298,  1299,  1300,   953,    66,    98,    99,   100,
+     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
+     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
+     121,   122,   123,   124,   125,   126,  1240,  1241,  1242,   580,
+      34,    35,    36,    37,   581,   127,   128,   129,   130,   584,
+     433,   434,   156,   506,   585,   129,   130,  1141,   985,  1142,
+    1143,  1150,   131,  1156,   435,   436,   345,   132,   133,   134,
+     135,   136,   137,   138,   584,   139,   914,   513,  1005,   986,
+     140,   156,   987,  1006,   817,   129,   130,  1026,   156,   141,
+    1027,   156,   142,  1005,  1032,   880,  1107,  1033,  1007,   143,
+     437,   930,   931,   932,  1029,   920,  1046,   144,   145,  1030,
+     447,  1047,   146,  1053,  1072,   147,   812,  1073,  1054,   148,
+     813,   814,   815,   816,   817,   818,   819,   820,   821,   822,
+     823,   544,   448,   449,   824,   825,   826,   827,   828,   450,
+     149,   150,   151,   152,   153,   154,  1058,   129,   130,  1294,
+    1062,  1059,  1295,   451,   155,  1063,    98,    99,   100,   101,
+     102,   103,   156,   452,  1068,   546,   453,   580,   345,  1069,
+     156,   126,  1070,   454,   455,  1075,  1211,  1005,  1212,  1213,
+    1076,   456,  1248,   457,   126,   345,   304,   305,   306,   307,
+     308,   129,   130,   458,   525,   915,   916,   917,   918,  1249,
+     156,   459,   460,   462,   129,   130,   900,   901,   902,   903,
+     904,   905,   246,  1252,   563,   247,  1273,   528,  1253,  1260,
+     463,  1274,  1276,   535,   586,   587,  1162,  1163,  1277,  1314,
+     746,   747,   748,   749,  1315,   157,   871,   878,   464,   879,
+     465,   545,   229,   466,   470,   471,   472,   476,   481,   482,
+     483,   493,   500,   501,   249,   588,   502,   295,   237,   505,
+     509,   510,   156,   511,   309,   292,   256,   512,   520,   521,
+     289,   531,   533,   302,   329,   534,   549,   553,   554,   555,
+     313,   557,   250,   558,   351,   560,   559,   565,   568,   370,
+     331,   570,   571,   372,   257,   258,   373,   259,   260,   261,
+     365,   238,   156,   574,   575,   383,   156,   583,   589,   407,
+     352,   251,   590,   290,   591,   371,   303,   592,   593,   156,
+     594,   595,   610,   314,   605,   408,   596,   597,   598,   287,
+     599,   600,   298,   332,   604,   601,   602,   252,   606,   312,
+     616,   253,   603,   366,   262,   254,   129,   130,   384,   330,
+     607,   608,   609,   611,   617,   612,   618,   622,   255,   263,
+     623,   613,   264,   265,   614,   615,   266,   619,   409,   620,
+     624,   621,   626,   627,   267,   628,   625,   268,   629,   269,
+     270,   271,   633,   634,   272,   635,   630,   273,   631,   632,
+     636,   281,   637,   638,   282,   283,   639,   284,   640,   641,
+     643,   296,   644,   297,   642,   645,   646,   647,   310,   648,
+     311,   392,   393,   394,   395,   396,   397,   398,   399,   400,
+     401,   402,   403,   404,   652,   649,   653,   655,   650,   658,
+     651,   405,   406,     1,     2,     3,     4,     5,     6,     7,
+       8,     9,    10,    11,    12,    13,    14,   661,   656,   662,
+     663,   664,   157,   665,   668,   229,   669,   670,   672,   674,
+     676,   156,   680,   657,   659,   666,   681,   682,   683,   675,
+     684,   237,   677,   667,   685,   686,   688,   678,   689,   691,
+     690,   692,   693,   696,   700,   701,   704,   694,   919,   933,
+     943,   705,   407,   697,   698,   707,   967,   706,   703,   710,
+     708,   709,   711,   714,   921,   939,   944,   954,   408,   712,
+     713,   715,   808,   716,   238,    98,    99,   100,   101,   102,
+     103,   104,   105,   106,   107,   108,   109,   110,   717,   719,
+     720,   722,   115,   116,   117,   118,   119,   120,   121,   122,
+     123,   723,   724,   126,   725,   726,   727,   922,   940,   945,
+     955,   409,   728,   729,   730,   239,   737,   240,   738,   739,
+     740,   741,   802,   129,   130,   241,   242,   243,   244,   245,
+     131,   742,    32,   745,   751,   132,   133,   134,   752,   753,
+     764,   755,   754,   756,   246,   757,   758,   247,   140,   759,
+     760,   761,   762,   763,   765,   248,   766,   767,   768,   770,
+     771,   772,   807,   773,    98,    99,   100,   101,   102,   103,
+     104,   105,   106,   107,   108,   109,   110,   774,   776,   777,
+     778,   115,   116,   117,   118,   119,   120,   121,   122,   123,
+     124,   779,   126,   345,   780,   784,   785,   786,   787,   788,
+     789,   790,   791,   792,   793,   794,   796,   797,   149,   150,
+     798,   804,   129,   130,   805,   242,   243,   851,   245,   131,
+     855,   806,   859,   863,   132,   133,   134,   867,   889,   892,
+     896,   963,   885,   246,   972,   976,   247,   992,   156,   993,
+     994,   995,   996,   997,   248,   998,  1000,  1010,  1087,  1009,
+    1013,  1012,  1015,  1016,  1018,  1019,  1022,  1021,  1077,  1036,
+    1025,  1035,  1039,  1038,  1040,  1041,  1042,  1043,  1044,  1045,
+    1050,  1051,  1052,  1055,  1056,  1057,  1064,  1066,  1074,  1082,
+    1237,  1081,  1085,  1084,  1088,  1089,  1090,  1091,  1092,  1093,
+    1094,  1095,  1096,  1097,  1098,  1100,  1102,   149,   150,  1099,
+     249,  1101,  1103,   351,  1104,  1105,   370,  1160,  1193,  1115,
+     372,   292,   256,   373,  1186,  1187,   289,  1188,  1189,   365,
+    1164,  1122,   383,   329,  1190,  1154,   387,   156,   250,   352,
+    1191,  1194,   371,  1195,  1196,  1140,  1173,  1116,  1197,   331,
+     257,   258,   919,   259,   260,   261,  1171,   933,  1165,  1123,
+    1124,   943,  1125,  1126,  1127,  1203,  1204,   251,   921,   290,
+    1214,  1199,   366,   939,   967,   384,  1117,   944,  1155,   295,
+    1200,  1201,   309,   954,  1206,   287,  1216,  1166,  1207,  1174,
+    1208,  1209,   332,   252,  1153,   302,  1215,   253,   313,  1224,
+     262,   254,  1118,  1226,  1227,  1172,  1119,  1232,   330,  1128,
+    1120,   922,  1238,  1167,   255,   263,   940,  1168,   264,   265,
+     945,  1169,   266,  1121,  1129,  1239,   955,  1130,  1131,  1217,
+     267,  1132,  1244,   268,  1170,   269,   270,   271,   303,  1133,
+     272,   314,  1134,   273,  1135,  1136,  1137,   281,  1250,  1138,
+     282,   283,  1139,   284,   298,  1251,  1146,   312,  1256,  1147,
+    1148,  1257,  1149,  1144,  1258,  1145,  1259,  1271,  1280,  1245,
+    1283,  1285,  1290,  1288,  1310,  1311,  1312,  1316,  1246,  1320,
+     795,   809,   877,   811,   803,   654,  1106,   660,  1161,  1108,
+    1158,   984,  1202,  1185,  1159,  1184,  1192,   702,  1110,  1109,
+    1247,   671,  1157,  1279,   343,  1254,  1265,  1266,  1267,  1268,
+    1275,  1112,  1111,  1278,  1113,   695,  1284,  1281,  1228,  1287,
+    1317,  1114,  1289,   296,   679,   297,   310,  1318,   311,  1319,
+    1322,  1323,  1231,   687,  1229,  1282,   673,  1183,  1230,  1182,
+    1181,   699,   981,  1198,  1205,  1210,  1223,   718,  1308,  1286,
+    1321,  1115,   962,   721,     0,     0,     0,  1164,     0,  1225,
+       0,     0,     0,  1122,     0,     0,     0,  1154,     0,  1269,
+     810,     0,  1214,  1173,     0,     0,     0,  1140,     0,  1116,
+       0,     0,     0,  1171,     0,  1165,     0,     0,  1216,     0,
+       0,  1123,  1124,     0,  1125,  1126,  1127,     0,  1215,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,  1117,     0,
+    1155,     0,     0,     0,  1166,     0,  1174,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,  1153,     0,     0,     0,
+       0,  1217,  1172,     0,  1118,     0,     0,     0,  1119,     0,
+    1167,  1128,  1120,     0,  1168,     0,     0,     0,  1169,     0,
+       0,     0,     0,     0,     0,  1121,  1129,     0,     0,  1130,
+    1131,  1170,     0,  1132,     0,     0,     0,     0,     0,     0,
+       0,  1133,     0,     0,  1134,     0,  1135,  1136,  1137,     0,
+       0,  1138,     0,     0,  1139,     0,     0,     0,  1146,     0,
+       0,  1147,  1148,     0,  1149,  1144,     0,  1145
+  };
+
+  const short
+  Dhcp6Parser::yycheck_[] =
+  {
+      71,    72,    73,    74,    75,    76,    16,    78,    79,    80,
+      81,   759,    79,    73,    73,    79,   728,    72,    73,    74,
+      75,    76,   753,    78,    79,  1020,    81,  1020,  1020,  1020,
+      73,  1020,   123,    78,    79,     5,     0,     7,   627,     9,
+     130,   131,    73,    73,   210,    73,    73,    73,    13,    14,
+     195,    76,    77,    78,    79,    80,    81,   130,   131,    73,
+      72,    73,    74,    75,    76,   210,    78,    79,     3,    81,
+      95,    96,    74,     8,   668,    95,    96,    73,    74,    75,
+      76,   176,   177,   178,   179,    73,   680,   681,   682,    73,
+      95,    96,    73,    73,    16,    17,    18,    19,    20,     3,
+       7,     7,   121,     3,     8,    24,    73,    73,     8,   128,
+      73,    73,   701,     7,    73,     7,     3,    75,   213,   210,
+     210,     8,    73,   173,   174,    73,     3,    73,    73,    73,
+      88,     8,    73,   153,   154,    73,     3,    95,    96,    73,
+      10,     8,    73,    73,     7,    73,    75,    74,    75,    74,
+      75,   156,   157,   158,    25,    26,    27,    76,   116,    78,
+      79,   119,     7,    82,    83,    84,    95,    96,   140,   141,
+     142,    11,    12,    95,    96,    15,    95,    96,     7,     3,
+       7,    21,    22,    23,     8,   210,   115,     7,     3,     7,
+     210,     6,   121,   122,   123,   124,   125,   126,   187,     7,
+       7,   190,   191,   192,   193,   210,     7,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,    39,    40,    41,     3,
+     210,   211,   212,   213,     8,    85,    86,    95,    96,     3,
+       6,     3,   210,     3,     8,    95,    96,  1252,     8,  1252,
+    1252,  1252,   102,  1252,     4,     8,    76,   107,   108,   109,
+     110,   111,   112,   113,     3,   115,    24,     3,     3,     8,
+     120,   210,     8,     8,    32,    95,    96,     3,   210,   129,
+       6,   210,   132,     3,     3,  1026,  1008,     6,     8,   139,
+       3,   149,   150,   151,     3,  1053,     3,   147,   148,     8,
+       4,     8,   152,     3,     3,   155,    24,     6,     8,   159,
+      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
+      38,     8,     4,     4,    42,    43,    44,    45,    46,     4,
+     180,   181,   182,   183,   184,   185,     3,    95,    96,     3,
+       3,     8,     6,     4,   194,     8,    47,    48,    49,    50,
+      51,    52,   210,     4,     3,     8,     4,     3,    76,     8,
+     210,    75,     8,     4,     4,     3,   186,     3,   188,   189,
+       8,     4,     8,     4,    75,    76,    90,    91,    92,    93,
+      94,    95,    96,     4,     3,   143,   144,   145,   146,     8,
+     210,     4,     4,     4,    95,    96,   133,   134,   135,   136,
+     137,   138,   116,     3,     3,   119,     3,     3,     8,     8,
+       4,     8,     8,     3,   434,   435,   117,   118,     8,     3,
+     103,   104,   105,   106,     8,   506,   123,   124,     4,   126,
+       4,     3,   513,     4,     4,     4,     4,     4,     4,     4,
+       4,     4,     4,     4,   525,   210,     4,   528,   513,     4,
+       4,     4,   210,     4,   535,   525,   525,     4,     4,     4,
+     525,     4,     4,   528,   545,     4,     4,     4,     8,     3,
+     535,     4,   525,     4,   555,     3,     8,     4,     4,   560,
+     545,     4,     4,   560,   525,   525,   560,   525,   525,   525,
+     555,   513,   210,     4,     4,   560,   210,     4,     4,   580,
+     555,   525,     4,   525,     4,   560,   528,     4,     4,   210,
+       4,     4,     4,   535,   212,   580,   211,   211,   211,   525,
+     211,   211,   528,   545,   213,   211,   211,   525,   212,   535,
+       4,   525,   211,   555,   525,   525,    95,    96,   560,   545,
+     212,   211,   211,   211,     4,   211,     4,     4,   525,   525,
+       4,   213,   525,   525,   213,   213,   525,   213,   580,   213,
+       4,   213,     4,     4,   525,     4,   211,   525,     4,   525,
+     525,   525,     4,     4,   525,     4,   213,   525,   213,   213,
+       4,   525,     4,     4,   525,   525,     4,   525,     4,     4,
+       4,   528,     4,   528,   211,     4,     4,     4,   535,     4,
+     535,   160,   161,   162,   163,   164,   165,   166,   167,   168,
+     169,   170,   171,   172,     4,   213,     4,     4,   213,   211,
+     213,   180,   181,   196,   197,   198,   199,   200,   201,   202,
+     203,   204,   205,   206,   207,   208,   209,     4,   213,     4,
+       4,     4,   723,     4,     4,   726,     4,     4,     4,     4,
+       4,   210,     4,   213,   211,   211,     4,     4,     4,   211,
+       4,   726,   211,   213,     4,     4,     4,   211,     4,     4,
+     211,     4,     4,     4,     4,     4,     4,   213,   759,   760,
+     761,     4,   763,   213,   213,     4,   767,   211,   213,     4,
+     211,   211,     4,     4,   759,   760,   761,   762,   763,   213,
+     213,     4,   722,     4,   726,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,     4,     4,
+     211,     4,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,     7,   210,    75,     7,     7,     7,   759,   760,   761,
+     762,   763,     7,     5,   210,    87,   210,    89,   210,     5,
+       5,     5,   175,    95,    96,    97,    98,    99,   100,   101,
+     102,     5,     7,   210,     5,   107,   108,   109,     5,     5,
+     210,     5,     7,     5,   116,     5,     7,   119,   120,     7,
+       7,     7,     7,     7,   210,   127,     5,     7,     5,     5,
+       5,   210,     5,   210,    47,    48,    49,    50,    51,    52,
+      53,    54,    55,    56,    57,    58,    59,   210,   210,     7,
+     210,    64,    65,    66,    67,    68,    69,    70,    71,    72,
+      73,   210,    75,    76,   210,   210,   210,   210,   210,   210,
+     210,   210,   210,   210,   210,   210,   210,   210,   180,   181,
+     210,   210,    95,    96,   210,    98,    99,     7,   101,   102,
+       7,   210,     7,     7,   107,   108,   109,     7,     7,     7,
+       7,     7,   114,   116,     7,     7,   119,     4,   210,     4,
+       4,     4,     4,     4,   127,     4,     4,     3,     8,     6,
+       3,     6,     6,     3,     6,     3,     3,     6,   210,     3,
+       6,     6,     3,     6,     4,     4,     4,     4,     4,     4,
+       4,     4,     4,     4,     4,     4,     4,     4,     4,     3,
+     210,     6,     3,     6,     6,     4,     4,     4,     4,   211,
+     213,   211,   213,   211,   211,     4,     4,   180,   181,   211,
+    1011,   211,     4,  1014,     4,     4,  1017,     4,     4,  1020,
+    1017,  1011,  1011,  1017,   211,   211,  1011,   211,   211,  1014,
+    1031,  1020,  1017,  1034,   211,  1020,  1037,   210,  1011,  1014,
+     211,     4,  1017,   211,   211,  1020,  1031,  1020,   211,  1034,
+    1011,  1011,  1053,  1011,  1011,  1011,  1031,  1058,  1031,  1020,
+    1020,  1062,  1020,  1020,  1020,     4,     4,  1011,  1053,  1011,
+    1071,   213,  1014,  1058,  1075,  1017,  1020,  1062,  1020,  1080,
+     211,   211,  1083,  1068,   213,  1011,  1071,  1031,     4,  1031,
+     211,     4,  1034,  1011,  1020,  1080,  1071,  1011,  1083,   213,
+    1011,  1011,  1020,     6,     3,  1031,  1020,     4,  1034,  1020,
+    1020,  1053,   210,  1031,  1011,  1011,  1058,  1031,  1011,  1011,
+    1062,  1031,  1011,  1020,  1020,   210,  1068,  1020,  1020,  1071,
+    1011,  1020,   210,  1011,  1031,  1011,  1011,  1011,  1080,  1020,
+    1011,  1083,  1020,  1011,  1020,  1020,  1020,  1011,     8,  1020,
+    1011,  1011,  1020,  1011,  1080,     8,  1020,  1083,     4,  1020,
+    1020,     8,  1020,  1020,     3,  1020,     8,     4,     4,   210,
+       4,     4,     7,     5,     4,     4,     4,     4,   210,     4,
+     701,   723,   752,   726,   714,   506,  1005,   513,  1029,  1010,
+    1023,   807,  1058,  1039,  1026,  1037,  1046,   563,  1013,  1011,
+     210,   525,  1022,  1252,    77,   210,   210,   210,   210,   210,
+     210,  1016,  1014,   210,  1017,   555,   211,   213,  1080,   210,
+     213,  1019,   210,  1080,   535,  1080,  1083,   211,  1083,   211,
+     210,   210,  1085,   545,  1082,  1258,   528,  1036,  1083,  1034,
+    1032,   560,   777,  1053,  1062,  1068,  1072,   580,  1294,  1273,
+    1314,  1252,   763,   584,    -1,    -1,    -1,  1258,    -1,  1075,
+      -1,    -1,    -1,  1252,    -1,    -1,    -1,  1252,    -1,  1209,
+     725,    -1,  1273,  1258,    -1,    -1,    -1,  1252,    -1,  1252,
+      -1,    -1,    -1,  1258,    -1,  1258,    -1,    -1,  1273,    -1,
+      -1,  1252,  1252,    -1,  1252,  1252,  1252,    -1,  1273,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,  1252,    -1,
+    1252,    -1,    -1,    -1,  1258,    -1,  1258,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,  1252,    -1,    -1,    -1,
+      -1,  1273,  1258,    -1,  1252,    -1,    -1,    -1,  1252,    -1,
+    1258,  1252,  1252,    -1,  1258,    -1,    -1,    -1,  1258,    -1,
+      -1,    -1,    -1,    -1,    -1,  1252,  1252,    -1,    -1,  1252,
+    1252,  1258,    -1,  1252,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,  1252,    -1,    -1,  1252,    -1,  1252,  1252,  1252,    -1,
+      -1,  1252,    -1,    -1,  1252,    -1,    -1,    -1,  1252,    -1,
+      -1,  1252,  1252,    -1,  1252,  1252,    -1,  1252
+  };
+
+  const short
+  Dhcp6Parser::yystos_[] =
+  {
+       0,   196,   197,   198,   199,   200,   201,   202,   203,   204,
+     205,   206,   207,   208,   209,   215,   216,   217,   218,   219,
+     220,   221,   222,   223,   224,   225,   226,   227,   228,   229,
+       0,     5,     7,     9,   210,   211,   212,   213,   230,   231,
+     232,   237,     7,   246,     7,   251,     7,   298,     7,   407,
+       7,   487,     7,   503,     7,   520,     7,   439,     7,   445,
+       7,   469,     7,   383,     7,   589,     7,   620,   238,   233,
+     247,   252,   299,   408,   488,   504,   521,   440,   446,   470,
+     384,   590,   621,   230,   239,   240,   210,   235,   236,    10,
+     248,   250,    11,    12,    15,    21,    22,    23,    47,    48,
+      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    71,    72,    73,    74,    75,    85,    86,    95,
+      96,   102,   107,   108,   109,   110,   111,   112,   113,   115,
+     120,   129,   132,   139,   147,   148,   152,   155,   159,   180,
+     181,   182,   183,   184,   185,   194,   210,   245,   253,   254,
+     255,   257,   258,   259,   260,   261,   262,   263,   264,   265,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   277,
+     279,   281,   282,   283,   285,   287,   288,   289,   290,   292,
+     293,   294,   295,   296,   308,   310,   312,   350,   356,   362,
+     368,   370,   377,   391,   401,   421,   422,   423,   424,   429,
+     437,   463,   493,   495,   514,   544,   556,   568,   569,   577,
+     587,   618,   627,   651,    16,    17,    18,    19,    20,   245,
+     300,   301,   302,   304,   305,   306,   307,   493,   495,    87,
+      89,    97,    98,    99,   100,   101,   116,   119,   127,   245,
+     257,   258,   259,   260,   261,   262,   263,   264,   265,   266,
+     267,   268,   269,   271,   272,   273,   274,   277,   279,   281,
+     282,   283,   285,   287,   409,   410,   411,   413,   415,   417,
+     419,   421,   422,   423,   424,   427,   428,   463,   481,   493,
+     495,   497,   514,   539,    88,   245,   417,   419,   463,   489,
+     490,   491,   493,   495,    90,    91,    92,    93,    94,   245,
+     417,   419,   463,   493,   495,   505,   506,   507,   509,   510,
+     512,   513,   115,   121,   122,   123,   124,   125,   126,   245,
+     463,   493,   495,   522,   523,   524,   525,   527,   529,   531,
+     533,   535,   537,   437,    24,    76,    78,    79,    82,    83,
+      84,   245,   330,   447,   448,   449,   450,   451,   452,   453,
+     455,   457,   459,   460,   462,   493,   495,    77,    80,    81,
+     245,   330,   451,   457,   471,   472,   473,   474,   475,   477,
+     478,   479,   480,   493,   495,   130,   131,   245,   385,   386,
+     387,   389,   160,   161,   162,   163,   164,   165,   166,   167,
+     168,   169,   170,   171,   172,   180,   181,   245,   493,   495,
+     591,   592,   593,   594,   596,   598,   599,   601,   602,   603,
+     606,   608,   609,   610,   612,   614,   616,    13,    14,   622,
+     623,   624,   626,     6,     3,     4,     8,     3,   249,     3,
+       8,   256,   619,   297,   309,   311,   313,     4,     4,     4,
+       4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
+       4,   291,     4,     4,     4,     4,     4,   275,   278,   280,
+       4,     4,     4,   402,   438,   464,     4,   430,   494,   496,
+     425,     4,     4,     4,   357,   369,   363,   351,   545,   515,
+     378,   392,   557,     4,   371,   570,   578,   588,   284,   286,
+       4,     4,     4,   628,   652,     4,     3,     8,   303,     4,
+       4,     4,     4,     3,     8,   482,   498,   412,   414,   416,
+       4,     4,   420,   418,   540,     3,     8,   492,     3,     8,
+     508,     4,   511,     4,     4,     3,     8,   538,   526,   528,
+     530,   532,   534,   536,     8,     3,     8,   454,   331,     4,
+     458,   456,   461,     4,     8,     3,   476,     4,     4,     8,
+       3,   388,   390,     3,     8,     4,   595,   597,     4,   600,
+       4,     4,   604,   607,     4,     4,   611,   613,   615,   617,
+       3,     8,   625,     4,     3,     8,   230,   230,   210,     4,
+       4,     4,     4,     4,     4,     4,   211,   211,   211,   211,
+     211,   211,   211,   211,   213,   212,   212,   212,   211,   211,
+       4,   211,   211,   213,   213,   213,     4,     4,     4,   213,
+     213,   213,     4,     4,     4,   211,     4,     4,     4,     4,
+     213,   213,   213,     4,     4,     4,     4,     4,     4,     4,
+       4,     4,   211,     4,     4,     4,     4,     4,     4,   213,
+     213,   213,     4,     4,   254,     4,   213,   213,   211,   211,
+     301,     4,     4,     4,     4,     4,   211,   213,     4,     4,
+       4,   410,     4,   490,     4,   211,     4,   211,   211,   506,
+       4,     4,     4,     4,     4,     4,     4,   524,     4,     4,
+     211,     4,     4,     4,   213,   449,     4,   213,   213,   473,
+       4,     4,   386,   213,     4,     4,   211,     4,   211,   211,
+       4,     4,   213,   213,     4,     4,     4,     4,   592,     4,
+     211,   623,     4,     7,   210,     7,     7,     7,     7,     5,
+     210,   176,   177,   178,   179,   213,   276,   210,   210,     5,
+       5,     5,     5,   232,   234,   210,   103,   104,   105,   106,
+     426,     5,     5,     5,     7,     5,     5,     5,     7,     7,
+       7,     7,     7,     7,   210,   210,     5,     7,     5,   241,
+       5,     5,   210,   210,   210,   241,   210,     7,   210,   210,
+     210,   241,   241,   241,   210,   210,   210,   210,   210,   210,
+     210,   210,   210,   210,   210,   234,   210,   210,   210,   173,
+     174,   605,   175,   276,   210,   210,   210,     5,   230,   253,
+     622,   300,    24,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    42,    43,    44,    45,    46,   245,
+     318,   319,   320,   323,   325,   327,   329,   330,   332,   333,
+     334,   335,   336,   337,   340,   341,   342,   344,   346,   348,
+     318,     7,   314,   315,   316,     7,   403,   404,   405,     7,
+     441,   442,   443,     7,   465,   466,   467,     7,   431,   432,
+     433,   123,   210,   358,   359,   360,   361,   239,   124,   126,
+     360,   364,   365,   366,   367,   114,   352,   353,   354,     7,
+     546,   547,     7,   516,   517,   518,     7,   379,   380,   381,
+     133,   134,   135,   136,   137,   138,   393,   394,   395,   396,
+     397,   398,   399,   400,    24,   143,   144,   145,   146,   245,
+     332,   493,   495,   558,   559,   560,   563,   564,   566,   567,
+     149,   150,   151,   245,   372,   373,   374,   375,   376,   493,
+     495,   153,   154,   245,   493,   495,   571,   572,   573,   575,
+     156,   157,   158,   210,   493,   495,   579,   580,   581,   582,
+     584,   585,   591,     7,   629,   630,   195,   245,   653,   654,
+     655,   242,     7,   483,   484,   485,     7,   499,   500,   501,
+     128,   525,   541,   542,   314,     8,     8,     8,   321,   324,
+     326,   328,     4,     4,     4,     4,     4,     4,     4,   338,
+       4,   343,   345,   347,   349,     3,     8,     8,   317,     6,
+       3,   406,     6,     3,   444,     6,     3,   468,     6,     3,
+     434,     6,     3,     3,     6,     6,     3,     6,   355,     3,
+       8,   548,     3,     6,   519,     6,     3,   382,     6,     3,
+       4,     4,     4,     4,     4,     4,     3,     8,   561,   565,
+       4,     4,     4,     3,     8,     4,     4,     4,     3,     8,
+     574,   576,     3,     8,     4,   583,     4,   586,     3,     8,
+       8,   631,     3,     6,     4,     3,     8,   210,   243,   244,
+     486,     6,     3,   502,     6,     3,   543,     8,     6,     4,
+       4,     4,     4,   211,   213,   211,   213,   211,   211,   211,
+       4,   211,     4,     4,     4,     4,   319,   318,   316,   409,
+     405,   447,   443,   471,   467,   245,   257,   258,   259,   260,
+     261,   262,   263,   264,   265,   266,   267,   268,   269,   271,
+     272,   273,   274,   277,   279,   281,   282,   283,   285,   287,
+     330,   401,   413,   415,   417,   419,   421,   422,   423,   424,
+     428,   435,   436,   463,   493,   495,   539,   433,   359,   365,
+       4,   353,   117,   118,   245,   257,   258,   259,   260,   261,
+     262,   330,   463,   493,   495,   549,   550,   551,   552,   553,
+     555,   547,   522,   518,   385,   381,   211,   211,   211,   211,
+     211,   211,   394,     4,     4,   211,   211,   211,   559,   213,
+     211,   211,   373,     4,     4,   572,   213,     4,   211,     4,
+     580,   186,   188,   189,   245,   330,   493,   495,   632,   633,
+     634,   635,   637,   630,   213,   654,     6,     3,   489,   485,
+     505,   501,     4,    25,    26,    27,   322,   210,   210,   210,
+      39,    40,    41,   339,   210,   210,   210,   210,     8,     8,
+       8,     8,     3,     8,   210,   554,     4,     8,     3,     8,
+       8,   140,   141,   142,   562,   210,   210,   210,   210,   230,
+     638,     4,   636,     3,     8,   210,     8,     8,   210,   436,
+       4,   213,   551,     4,   211,     4,   633,   210,     5,   210,
+       7,   639,   640,   641,     3,     6,   187,   190,   191,   192,
+     193,   642,   643,   644,   646,   647,   648,   649,   640,   645,
+       4,     4,     4,   650,     3,     8,     4,   213,   211,   211,
+       4,   643,   210,   210
+  };
+
+  const short
+  Dhcp6Parser::yyr1_[] =
+  {
+       0,   214,   216,   215,   217,   215,   218,   215,   219,   215,
+     220,   215,   221,   215,   222,   215,   223,   215,   224,   215,
+     225,   215,   226,   215,   227,   215,   228,   215,   229,   215,
+     230,   230,   230,   230,   230,   230,   230,   231,   233,   232,
+     234,   235,   235,   236,   236,   236,   238,   237,   239,   239,
+     240,   240,   240,   242,   241,   243,   243,   244,   244,   244,
+     245,   247,   246,   249,   248,   248,   250,   252,   251,   253,
+     253,   253,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   254,   254,   254,
+     254,   254,   254,   254,   254,   254,   254,   256,   255,   257,
+     258,   259,   260,   261,   262,   263,   264,   265,   266,   267,
+     268,   269,   270,   271,   272,   273,   275,   274,   276,   276,
+     276,   276,   276,   278,   277,   280,   279,   281,   282,   284,
+     283,   286,   285,   287,   288,   289,   291,   290,   292,   293,
+     294,   295,   297,   296,   299,   298,   300,   300,   300,   301,
+     301,   301,   301,   301,   301,   301,   301,   303,   302,   304,
+     305,   306,   307,   309,   308,   311,   310,   313,   312,   314,
+     314,   315,   315,   315,   317,   316,   318,   318,   318,   319,
+     319,   319,   319,   319,   319,   319,   319,   319,   319,   319,
+     319,   319,   319,   319,   319,   319,   319,   319,   321,   320,
+     322,   322,   322,   324,   323,   326,   325,   328,   327,   329,
+     331,   330,   332,   333,   334,   335,   336,   338,   337,   339,
+     339,   339,   340,   341,   343,   342,   345,   344,   347,   346,
+     349,   348,   351,   350,   352,   352,   352,   353,   355,   354,
+     357,   356,   358,   358,   358,   359,   359,   360,   361,   363,
+     362,   364,   364,   364,   365,   365,   365,   366,   367,   369,
+     368,   371,   370,   372,   372,   372,   373,   373,   373,   373,
+     373,   373,   374,   375,   376,   378,   377,   379,   379,   380,
+     380,   380,   382,   381,   384,   383,   385,   385,   385,   385,
+     386,   386,   388,   387,   390,   389,   392,   391,   393,   393,
+     393,   394,   394,   394,   394,   394,   394,   395,   396,   397,
+     398,   399,   400,   402,   401,   403,   403,   404,   404,   404,
+     406,   405,   408,   407,   409,   409,   409,   410,   410,   410,
+     410,   410,   410,   410,   410,   410,   410,   410,   410,   410,
+     410,   410,   410,   410,   410,   410,   410,   410,   410,   410,
+     410,   410,   410,   410,   410,   410,   410,   410,   410,   410,
+     410,   410,   410,   410,   410,   410,   410,   410,   410,   410,
+     412,   411,   414,   413,   416,   415,   418,   417,   420,   419,
+     421,   422,   423,   425,   424,   426,   426,   426,   426,   427,
+     428,   430,   429,   431,   431,   432,   432,   432,   434,   433,
+     435,   435,   435,   436,   436,   436,   436,   436,   436,   436,
+     436,   436,   436,   436,   436,   436,   436,   436,   436,   436,
+     436,   436,   436,   436,   436,   436,   436,   436,   436,   436,
+     436,   436,   436,   436,   436,   436,   436,   436,   436,   436,
+     436,   436,   436,   438,   437,   440,   439,   441,   441,   442,
+     442,   442,   444,   443,   446,   445,   447,   447,   448,   448,
+     448,   449,   449,   449,   449,   449,   449,   449,   449,   449,
+     449,   450,   451,   452,   454,   453,   456,   455,   458,   457,
+     459,   461,   460,   462,   464,   463,   465,   465,   466,   466,
+     466,   468,   467,   470,   469,   471,   471,   472,   472,   472,
+     473,   473,   473,   473,   473,   473,   473,   473,   473,   474,
+     476,   475,   477,   478,   479,   480,   482,   481,   483,   483,
+     484,   484,   484,   486,   485,   488,   487,   489,   489,   489,
+     490,   490,   490,   490,   490,   490,   490,   492,   491,   494,
+     493,   496,   495,   498,   497,   499,   499,   500,   500,   500,
+     502,   501,   504,   503,   505,   505,   505,   506,   506,   506,
+     506,   506,   506,   506,   506,   506,   506,   506,   508,   507,
+     509,   511,   510,   512,   513,   515,   514,   516,   516,   517,
+     517,   517,   519,   518,   521,   520,   522,   522,   523,   523,
+     523,   524,   524,   524,   524,   524,   524,   524,   524,   524,
+     524,   524,   526,   525,   528,   527,   530,   529,   532,   531,
+     534,   533,   536,   535,   538,   537,   540,   539,   541,   541,
+     543,   542,   545,   544,   546,   546,   546,   548,   547,   549,
+     549,   550,   550,   550,   551,   551,   551,   551,   551,   551,
+     551,   551,   551,   551,   551,   551,   551,   552,   554,   553,
+     555,   557,   556,   558,   558,   558,   559,   559,   559,   559,
+     559,   559,   559,   559,   559,   561,   560,   562,   562,   562,
+     563,   565,   564,   566,   567,   568,   570,   569,   571,   571,
+     571,   572,   572,   572,   572,   572,   574,   573,   576,   575,
+     578,   577,   579,   579,   579,   580,   580,   580,   580,   580,
+     580,   581,   583,   582,   584,   586,   585,   588,   587,   590,
+     589,   591,   591,   591,   592,   592,   592,   592,   592,   592,
+     592,   592,   592,   592,   592,   592,   592,   592,   592,   592,
+     592,   592,   593,   595,   594,   597,   596,   598,   600,   599,
+     601,   602,   604,   603,   605,   605,   607,   606,   608,   609,
+     611,   610,   613,   612,   615,   614,   617,   616,   619,   618,
+     621,   620,   622,   622,   622,   623,   623,   625,   624,   626,
+     628,   627,   629,   629,   629,   631,   630,   632,   632,   632,
+     633,   633,   633,   633,   633,   633,   633,   634,   636,   635,
+     638,   637,   639,   639,   639,   641,   640,   642,   642,   642,
+     643,   643,   643,   643,   643,   645,   644,   646,   647,   648,
+     650,   649,   652,   651,   653,   653,   653,   654,   654,   655
+  };
+
+  const signed char
+  Dhcp6Parser::yyr2_[] =
+  {
+       0,     2,     0,     3,     0,     3,     0,     3,     0,     3,
+       0,     3,     0,     3,     0,     3,     0,     3,     0,     3,
+       0,     3,     0,     3,     0,     3,     0,     3,     0,     3,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
+       1,     0,     1,     3,     5,     2,     0,     4,     0,     1,
+       1,     3,     2,     0,     4,     0,     1,     1,     3,     2,
+       2,     0,     4,     0,     6,     1,     2,     0,     4,     1,
+       3,     2,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     0,     4,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     0,     4,     1,     1,
+       1,     1,     1,     0,     4,     0,     4,     3,     3,     0,
+       4,     0,     4,     3,     3,     3,     0,     4,     3,     3,
+       3,     3,     0,     6,     0,     4,     1,     3,     2,     1,
+       1,     1,     1,     1,     1,     1,     1,     0,     4,     3,
+       3,     3,     3,     0,     6,     0,     6,     0,     6,     0,
+       1,     1,     3,     2,     0,     4,     1,     3,     2,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
+       1,     1,     1,     0,     4,     0,     4,     0,     4,     3,
+       0,     4,     3,     3,     3,     3,     3,     0,     4,     1,
+       1,     1,     3,     3,     0,     4,     0,     4,     0,     4,
+       0,     4,     0,     6,     1,     3,     2,     1,     0,     4,
+       0,     6,     1,     3,     2,     1,     1,     1,     1,     0,
+       6,     1,     3,     2,     1,     1,     1,     1,     1,     0,
+       6,     0,     6,     1,     3,     2,     1,     1,     1,     1,
+       1,     1,     3,     3,     3,     0,     6,     0,     1,     1,
+       3,     2,     0,     4,     0,     4,     1,     3,     2,     1,
+       1,     1,     0,     4,     0,     4,     0,     6,     1,     3,
+       2,     1,     1,     1,     1,     1,     1,     3,     3,     3,
+       3,     3,     3,     0,     6,     0,     1,     1,     3,     2,
+       0,     4,     0,     4,     1,     3,     2,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       0,     4,     0,     4,     0,     4,     0,     4,     0,     4,
+       3,     3,     3,     0,     4,     1,     1,     1,     1,     3,
+       3,     0,     6,     0,     1,     1,     3,     2,     0,     4,
+       1,     3,     2,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     0,     6,     0,     4,     0,     1,     1,
+       3,     2,     0,     4,     0,     4,     0,     1,     1,     3,
+       2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     3,     1,     0,     4,     0,     4,     0,     4,
+       1,     0,     4,     3,     0,     6,     0,     1,     1,     3,
+       2,     0,     4,     0,     4,     0,     1,     1,     3,     2,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       0,     4,     1,     1,     3,     3,     0,     6,     0,     1,
+       1,     3,     2,     0,     4,     0,     4,     1,     3,     2,
+       1,     1,     1,     1,     1,     1,     1,     0,     4,     0,
+       4,     0,     4,     0,     6,     0,     1,     1,     3,     2,
+       0,     4,     0,     4,     1,     3,     2,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
+       3,     0,     4,     3,     3,     0,     6,     0,     1,     1,
+       3,     2,     0,     4,     0,     4,     0,     1,     1,     3,
+       2,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     0,     4,     0,     4,     0,     4,     0,     4,
+       0,     4,     0,     4,     0,     4,     0,     6,     1,     1,
+       0,     4,     0,     6,     1,     3,     2,     0,     4,     0,
+       1,     1,     3,     2,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     0,     4,
+       3,     0,     6,     1,     3,     2,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     0,     4,     1,     1,     1,
+       3,     0,     4,     3,     3,     3,     0,     6,     1,     3,
+       2,     1,     1,     1,     1,     1,     0,     4,     0,     4,
+       0,     6,     1,     3,     2,     1,     1,     1,     1,     1,
+       1,     3,     0,     4,     3,     0,     4,     0,     6,     0,
+       4,     1,     3,     2,     1,     1,     1,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+       1,     1,     3,     0,     4,     0,     4,     3,     0,     4,
+       3,     3,     0,     4,     1,     1,     0,     4,     3,     3,
+       0,     4,     0,     4,     0,     4,     0,     4,     0,     6,
+       0,     4,     1,     3,     2,     1,     1,     0,     6,     3,
+       0,     6,     1,     3,     2,     0,     4,     1,     3,     2,
+       1,     1,     1,     1,     1,     1,     1,     3,     0,     4,
+       0,     6,     1,     3,     2,     0,     4,     1,     3,     2,
+       1,     1,     1,     1,     1,     0,     4,     3,     3,     3,
+       0,     4,     0,     6,     1,     3,     2,     1,     1,     3
+  };
+
+
+#if PARSER6_DEBUG || 1
+  // YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+  // First, the terminals, then, starting at \a YYNTOKENS, nonterminals.
+  const char*
+  const Dhcp6Parser::yytname_[] =
+  {
+  "\"end of file\"", "error", "\"invalid token\"", "\",\"", "\":\"",
+  "\"[\"", "\"]\"", "\"{\"", "\"}\"", "\"null\"", "\"Dhcp6\"",
+  "\"data-directory\"", "\"config-control\"", "\"config-databases\"",
+  "\"config-fetch-wait-time\"", "\"interfaces-config\"", "\"interfaces\"",
+  "\"re-detect\"", "\"service-sockets-require-all\"",
+  "\"service-sockets-retry-wait-time\"", "\"service-sockets-max-retries\"",
+  "\"lease-database\"", "\"hosts-database\"", "\"hosts-databases\"",
+  "\"type\"", "\"memfile\"", "\"mysql\"", "\"postgresql\"", "\"user\"",
+  "\"password\"", "\"host\"", "\"port\"", "\"persist\"",
+  "\"lfc-interval\"", "\"readonly\"", "\"connect-timeout\"",
+  "\"max-reconnect-tries\"", "\"reconnect-wait-time\"", "\"on-fail\"",
+  "\"stop-retry-exit\"", "\"serve-retry-exit\"",
+  "\"serve-retry-continue\"", "\"max-row-errors\"", "\"trust-anchor\"",
+  "\"cert-file\"", "\"key-file\"", "\"cipher-list\"",
+  "\"preferred-lifetime\"", "\"min-preferred-lifetime\"",
+  "\"max-preferred-lifetime\"", "\"valid-lifetime\"",
+  "\"min-valid-lifetime\"", "\"max-valid-lifetime\"", "\"renew-timer\"",
+  "\"rebind-timer\"", "\"calculate-tee-times\"", "\"t1-percent\"",
+  "\"t2-percent\"", "\"cache-threshold\"", "\"cache-max-age\"",
+  "\"decline-probation-period\"", "\"server-tag\"",
+  "\"statistic-default-sample-count\"", "\"statistic-default-sample-age\"",
+  "\"ddns-send-updates\"", "\"ddns-override-no-update\"",
+  "\"ddns-override-client-update\"", "\"ddns-replace-client-name\"",
+  "\"ddns-generated-prefix\"", "\"ddns-qualifying-suffix\"",
+  "\"ddns-update-on-renew\"", "\"ddns-use-conflict-resolution\"",
+  "\"store-extended-info\"", "\"subnet6\"", "\"option-def\"",
+  "\"option-data\"", "\"name\"", "\"data\"", "\"code\"", "\"space\"",
+  "\"csv-format\"", "\"always-send\"", "\"record-types\"",
+  "\"encapsulate\"", "\"array\"", "\"parked-packet-limit\"",
+  "\"shared-networks\"", "\"pools\"", "\"pool\"", "\"pd-pools\"",
+  "\"prefix\"", "\"prefix-len\"", "\"excluded-prefix\"",
+  "\"excluded-prefix-len\"", "\"delegated-len\"", "\"user-context\"",
+  "\"comment\"", "\"subnet\"", "\"interface\"", "\"interface-id\"",
+  "\"id\"", "\"rapid-commit\"", "\"reservation-mode\"", "\"disabled\"",
+  "\"out-of-pool\"", "\"global\"", "\"all\"", "\"reservations-global\"",
+  "\"reservations-in-subnet\"", "\"reservations-out-of-pool\"",
+  "\"mac-sources\"", "\"relay-supplied-options\"",
+  "\"host-reservation-identifiers\"", "\"sanity-checks\"",
+  "\"lease-checks\"", "\"client-classes\"", "\"require-client-classes\"",
+  "\"test\"", "\"only-if-required\"", "\"client-class\"",
+  "\"reservations\"", "\"ip-addresses\"", "\"prefixes\"", "\"duid\"",
+  "\"hw-address\"", "\"hostname\"", "\"flex-id\"", "\"relay\"",
+  "\"ip-address\"", "\"hooks-libraries\"", "\"library\"", "\"parameters\"",
+  "\"expired-leases-processing\"", "\"reclaim-timer-wait-time\"",
+  "\"flush-reclaimed-timer-wait-time\"", "\"hold-reclaimed-time\"",
+  "\"max-reclaim-leases\"", "\"max-reclaim-time\"",
+  "\"unwarned-reclaim-cycles\"", "\"server-id\"", "\"LLT\"", "\"EN\"",
+  "\"LL\"", "\"identifier\"", "\"htype\"", "\"time\"", "\"enterprise-id\"",
+  "\"dhcp4o6-port\"", "\"multi-threading\"", "\"enable-multi-threading\"",
+  "\"thread-pool-size\"", "\"packet-queue-size\"", "\"control-socket\"",
+  "\"socket-type\"", "\"socket-name\"", "\"dhcp-queue-control\"",
+  "\"enable-queue\"", "\"queue-type\"", "\"capacity\"", "\"dhcp-ddns\"",
+  "\"enable-updates\"", "\"qualifying-suffix\"", "\"server-ip\"",
+  "\"server-port\"", "\"sender-ip\"", "\"sender-port\"",
+  "\"max-queue-size\"", "\"ncr-protocol\"", "\"ncr-format\"",
+  "\"override-no-update\"", "\"override-client-update\"",
+  "\"replace-client-name\"", "\"generated-prefix\"", "\"UDP\"", "\"TCP\"",
+  "\"JSON\"", "\"when-present\"", "\"never\"", "\"always\"",
+  "\"when-not-present\"", "\"hostname-char-set\"",
+  "\"hostname-char-replacement\"", "\"early-global-reservations-lookup\"",
+  "\"ip-reservations-unique\"", "\"reservations-lookup-first\"",
+  "\"loggers\"", "\"output_options\"", "\"output\"", "\"debuglevel\"",
+  "\"severity\"", "\"flush\"", "\"maxsize\"", "\"maxver\"", "\"pattern\"",
+  "\"compatibility\"", "\"lenient-option-parsing\"", "TOPLEVEL_JSON",
+  "TOPLEVEL_DHCP6", "SUB_DHCP6", "SUB_INTERFACES6", "SUB_SUBNET6",
+  "SUB_POOL6", "SUB_PD_POOL", "SUB_RESERVATION", "SUB_OPTION_DEFS",
+  "SUB_OPTION_DEF", "SUB_OPTION_DATA", "SUB_HOOKS_LIBRARY",
+  "SUB_DHCP_DDNS", "SUB_CONFIG_CONTROL", "\"constant string\"",
+  "\"integer\"", "\"floating point\"", "\"boolean\"", "$accept", "start",
+  "$@1", "$@2", "$@3", "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10",
+  "$@11", "$@12", "$@13", "$@14", "value", "sub_json", "map2", "$@15",
+  "map_value", "map_content", "not_empty_map", "list_generic", "$@16",
+  "list_content", "not_empty_list", "list_strings", "$@17",
+  "list_strings_content", "not_empty_list_strings", "unknown_map_entry",
+  "syntax_map", "$@18", "global_object", "$@19", "global_object_comma",
+  "sub_dhcp6", "$@20", "global_params", "global_param", "data_directory",
+  "$@21", "preferred_lifetime", "min_preferred_lifetime",
+  "max_preferred_lifetime", "valid_lifetime", "min_valid_lifetime",
+  "max_valid_lifetime", "renew_timer", "rebind_timer",
+  "calculate_tee_times", "t1_percent", "t2_percent", "cache_threshold",
+  "cache_max_age", "decline_probation_period", "ddns_send_updates",
+  "ddns_override_no_update", "ddns_override_client_update",
+  "ddns_replace_client_name", "$@22", "ddns_replace_client_name_value",
+  "ddns_generated_prefix", "$@23", "ddns_qualifying_suffix", "$@24",
+  "ddns_update_on_renew", "ddns_use_conflict_resolution",
+  "hostname_char_set", "$@25", "hostname_char_replacement", "$@26",
+  "store_extended_info", "statistic_default_sample_count",
+  "statistic_default_sample_age", "server_tag", "$@27",
+  "parked_packet_limit", "early_global_reservations_lookup",
+  "ip_reservations_unique", "reservations_lookup_first",
+  "interfaces_config", "$@28", "sub_interfaces6", "$@29",
+  "interfaces_config_params", "interfaces_config_param", "interfaces_list",
+  "$@30", "re_detect", "service_sockets_require_all",
+  "service_sockets_retry_wait_time", "service_sockets_max_retries",
+  "lease_database", "$@31", "hosts_database", "$@32", "hosts_databases",
+  "$@33", "database_list", "not_empty_database_list", "database", "$@34",
+  "database_map_params", "database_map_param", "database_type", "$@35",
+  "db_type", "user", "$@36", "password", "$@37", "host", "$@38", "port",
+  "name", "$@39", "persist", "lfc_interval", "readonly", "connect_timeout",
+  "reconnect_wait_time", "on_fail", "$@40", "on_fail_mode",
+  "max_row_errors", "max_reconnect_tries", "trust_anchor", "$@41",
+  "cert_file", "$@42", "key_file", "$@43", "cipher_list", "$@44",
+  "sanity_checks", "$@45", "sanity_checks_params", "sanity_checks_param",
+  "lease_checks", "$@46", "mac_sources", "$@47", "mac_sources_list",
+  "mac_sources_value", "duid_id", "string_id",
+  "host_reservation_identifiers", "$@48",
+  "host_reservation_identifiers_list", "host_reservation_identifier",
+  "hw_address_id", "flex_id", "relay_supplied_options", "$@49",
+  "dhcp_multi_threading", "$@50", "multi_threading_params",
+  "multi_threading_param", "enable_multi_threading", "thread_pool_size",
+  "packet_queue_size", "hooks_libraries", "$@51", "hooks_libraries_list",
+  "not_empty_hooks_libraries_list", "hooks_library", "$@52",
+  "sub_hooks_library", "$@53", "hooks_params", "hooks_param", "library",
+  "$@54", "parameters", "$@55", "expired_leases_processing", "$@56",
+  "expired_leases_params", "expired_leases_param",
+  "reclaim_timer_wait_time", "flush_reclaimed_timer_wait_time",
+  "hold_reclaimed_time", "max_reclaim_leases", "max_reclaim_time",
+  "unwarned_reclaim_cycles", "subnet6_list", "$@57",
+  "subnet6_list_content", "not_empty_subnet6_list", "subnet6", "$@58",
+  "sub_subnet6", "$@59", "subnet6_params", "subnet6_param", "subnet",
+  "$@60", "interface", "$@61", "interface_id", "$@62", "client_class",
+  "$@63", "require_client_classes", "$@64", "reservations_global",
+  "reservations_in_subnet", "reservations_out_of_pool", "reservation_mode",
+  "$@65", "hr_mode", "id", "rapid_commit", "shared_networks", "$@66",
+  "shared_networks_content", "shared_networks_list", "shared_network",
+  "$@67", "shared_network_params", "shared_network_param",
+  "option_def_list", "$@68", "sub_option_def_list", "$@69",
+  "option_def_list_content", "not_empty_option_def_list",
+  "option_def_entry", "$@70", "sub_option_def", "$@71",
+  "option_def_params", "not_empty_option_def_params", "option_def_param",
+  "option_def_name", "code", "option_def_code", "option_def_type", "$@72",
+  "option_def_record_types", "$@73", "space", "$@74", "option_def_space",
+  "option_def_encapsulate", "$@75", "option_def_array", "option_data_list",
+  "$@76", "option_data_list_content", "not_empty_option_data_list",
+  "option_data_entry", "$@77", "sub_option_data", "$@78",
+  "option_data_params", "not_empty_option_data_params",
+  "option_data_param", "option_data_name", "option_data_data", "$@79",
+  "option_data_code", "option_data_space", "option_data_csv_format",
+  "option_data_always_send", "pools_list", "$@80", "pools_list_content",
+  "not_empty_pools_list", "pool_list_entry", "$@81", "sub_pool6", "$@82",
+  "pool_params", "pool_param", "pool_entry", "$@83", "user_context",
+  "$@84", "comment", "$@85", "pd_pools_list", "$@86",
+  "pd_pools_list_content", "not_empty_pd_pools_list", "pd_pool_entry",
+  "$@87", "sub_pd_pool", "$@88", "pd_pool_params", "pd_pool_param",
+  "pd_prefix", "$@89", "pd_prefix_len", "excluded_prefix", "$@90",
+  "excluded_prefix_len", "pd_delegated_len", "reservations", "$@91",
+  "reservations_list", "not_empty_reservations_list", "reservation",
+  "$@92", "sub_reservation", "$@93", "reservation_params",
+  "not_empty_reservation_params", "reservation_param", "ip_addresses",
+  "$@94", "prefixes", "$@95", "duid", "$@96", "hw_address", "$@97",
+  "hostname", "$@98", "flex_id_value", "$@99",
+  "reservation_client_classes", "$@100", "relay", "$@101", "relay_map",
+  "ip_address", "$@102", "client_classes", "$@103", "client_classes_list",
+  "client_class_entry", "$@104", "client_class_params",
+  "not_empty_client_class_params", "client_class_param",
+  "client_class_name", "client_class_test", "$@105", "only_if_required",
+  "server_id", "$@106", "server_id_params", "server_id_param",
+  "server_id_type", "$@107", "duid_type", "htype", "identifier", "$@108",
+  "time", "enterprise_id", "dhcp4o6_port", "control_socket", "$@109",
+  "control_socket_params", "control_socket_param", "socket_type", "$@110",
+  "socket_name", "$@111", "dhcp_queue_control", "$@112",
+  "queue_control_params", "queue_control_param", "enable_queue",
+  "queue_type", "$@113", "capacity", "arbitrary_map_entry", "$@114",
+  "dhcp_ddns", "$@115", "sub_dhcp_ddns", "$@116", "dhcp_ddns_params",
+  "dhcp_ddns_param", "enable_updates", "dep_qualifying_suffix", "$@117",
+  "server_ip", "$@118", "server_port", "sender_ip", "$@119", "sender_port",
+  "max_queue_size", "ncr_protocol", "$@120", "ncr_protocol_value",
+  "ncr_format", "$@121", "dep_override_no_update",
+  "dep_override_client_update", "dep_replace_client_name", "$@122",
+  "dep_generated_prefix", "$@123", "dep_hostname_char_set", "$@124",
+  "dep_hostname_char_replacement", "$@125", "config_control", "$@126",
+  "sub_config_control", "$@127", "config_control_params",
+  "config_control_param", "config_databases", "$@128",
+  "config_fetch_wait_time", "loggers", "$@129", "loggers_entries",
+  "logger_entry", "$@130", "logger_params", "logger_param", "debuglevel",
+  "severity", "$@131", "output_options_list", "$@132",
+  "output_options_list_content", "output_entry", "$@133",
+  "output_params_list", "output_params", "output", "$@134", "flush",
+  "maxsize", "maxver", "pattern", "$@135", "compatibility", "$@136",
+  "compatibility_params", "compatibility_param", "lenient_option_parsing", YY_NULLPTR
+  };
+#endif
+
+
+#if PARSER6_DEBUG
+  const short
+  Dhcp6Parser::yyrline_[] =
+  {
+       0,   302,   302,   302,   303,   303,   304,   304,   305,   305,
+     306,   306,   307,   307,   308,   308,   309,   309,   310,   310,
+     311,   311,   312,   312,   313,   313,   314,   314,   315,   315,
+     323,   324,   325,   326,   327,   328,   329,   332,   337,   337,
+     348,   351,   352,   355,   360,   366,   371,   371,   378,   379,
+     382,   386,   390,   396,   396,   403,   404,   407,   411,   415,
+     425,   434,   434,   449,   449,   463,   466,   472,   472,   481,
+     482,   483,   490,   491,   492,   493,   494,   495,   496,   497,
+     498,   499,   500,   501,   502,   503,   504,   505,   506,   507,
+     508,   509,   510,   511,   512,   513,   514,   515,   516,   517,
+     518,   519,   520,   521,   522,   523,   524,   525,   526,   527,
+     528,   529,   530,   531,   532,   533,   534,   535,   536,   537,
+     538,   539,   540,   541,   542,   543,   544,   545,   546,   547,
+     548,   549,   550,   551,   552,   553,   554,   557,   557,   566,
+     572,   578,   584,   590,   596,   602,   608,   614,   620,   626,
+     632,   638,   644,   650,   656,   662,   668,   668,   677,   680,
+     683,   686,   689,   695,   695,   704,   704,   713,   719,   725,
+     725,   734,   734,   743,   749,   755,   761,   761,   770,   776,
+     782,   788,   794,   794,   806,   806,   815,   816,   817,   822,
+     823,   824,   825,   826,   827,   828,   829,   832,   832,   843,
+     849,   855,   861,   867,   867,   880,   880,   893,   893,   904,
+     905,   908,   909,   910,   915,   915,   925,   926,   927,   932,
+     933,   934,   935,   936,   937,   938,   939,   940,   941,   942,
+     943,   944,   945,   946,   947,   948,   949,   950,   953,   953,
+     961,   962,   963,   966,   966,   975,   975,   984,   984,   993,
+     999,   999,  1008,  1014,  1020,  1026,  1032,  1038,  1038,  1046,
+    1047,  1048,  1051,  1057,  1063,  1063,  1072,  1072,  1081,  1081,
+    1090,  1090,  1099,  1099,  1110,  1111,  1112,  1117,  1119,  1119,
+    1138,  1138,  1149,  1150,  1151,  1156,  1157,  1160,  1165,  1170,
+    1170,  1181,  1182,  1183,  1188,  1189,  1190,  1193,  1198,  1205,
+    1205,  1218,  1218,  1231,  1232,  1233,  1238,  1239,  1240,  1241,
+    1242,  1243,  1246,  1252,  1258,  1264,  1264,  1275,  1276,  1279,
+    1280,  1281,  1286,  1286,  1296,  1296,  1306,  1307,  1308,  1311,
+    1314,  1315,  1318,  1318,  1327,  1327,  1336,  1336,  1348,  1349,
+    1350,  1355,  1356,  1357,  1358,  1359,  1360,  1363,  1369,  1375,
+    1381,  1387,  1393,  1402,  1402,  1416,  1417,  1420,  1421,  1422,
+    1431,  1431,  1457,  1457,  1468,  1469,  1470,  1476,  1477,  1478,
+    1479,  1480,  1481,  1482,  1483,  1484,  1485,  1486,  1487,  1488,
+    1489,  1490,  1491,  1492,  1493,  1494,  1495,  1496,  1497,  1498,
+    1499,  1500,  1501,  1502,  1503,  1504,  1505,  1506,  1507,  1508,
+    1509,  1510,  1511,  1512,  1513,  1514,  1515,  1516,  1517,  1518,
+    1521,  1521,  1530,  1530,  1539,  1539,  1548,  1548,  1557,  1557,
+    1568,  1574,  1580,  1586,  1586,  1594,  1595,  1596,  1597,  1600,
+    1606,  1614,  1614,  1626,  1627,  1631,  1632,  1633,  1638,  1638,
+    1646,  1647,  1648,  1653,  1654,  1655,  1656,  1657,  1658,  1659,
+    1660,  1661,  1662,  1663,  1664,  1665,  1666,  1667,  1668,  1669,
+    1670,  1671,  1672,  1673,  1674,  1675,  1676,  1677,  1678,  1679,
+    1680,  1681,  1682,  1683,  1684,  1685,  1686,  1687,  1688,  1689,
+    1690,  1691,  1692,  1699,  1699,  1713,  1713,  1722,  1723,  1726,
+    1727,  1728,  1735,  1735,  1750,  1750,  1764,  1765,  1768,  1769,
+    1770,  1775,  1776,  1777,  1778,  1779,  1780,  1781,  1782,  1783,
+    1784,  1787,  1789,  1795,  1797,  1797,  1806,  1806,  1815,  1815,
+    1824,  1826,  1826,  1835,  1845,  1845,  1858,  1859,  1864,  1865,
+    1866,  1873,  1873,  1885,  1885,  1897,  1898,  1903,  1904,  1905,
+    1912,  1913,  1914,  1915,  1916,  1917,  1918,  1919,  1920,  1923,
+    1925,  1925,  1934,  1936,  1938,  1944,  1953,  1953,  1966,  1967,
+    1970,  1971,  1972,  1977,  1977,  1987,  1987,  1997,  1998,  1999,
+    2004,  2005,  2006,  2007,  2008,  2009,  2010,  2013,  2013,  2022,
+    2022,  2047,  2047,  2077,  2077,  2090,  2091,  2094,  2095,  2096,
+    2101,  2101,  2113,  2113,  2125,  2126,  2127,  2132,  2133,  2134,
+    2135,  2136,  2137,  2138,  2139,  2140,  2141,  2142,  2145,  2145,
+    2154,  2160,  2160,  2169,  2175,  2184,  2184,  2195,  2196,  2199,
+    2200,  2201,  2206,  2206,  2215,  2215,  2224,  2225,  2228,  2229,
+    2230,  2236,  2237,  2238,  2239,  2240,  2241,  2242,  2243,  2244,
+    2245,  2246,  2249,  2249,  2260,  2260,  2271,  2271,  2280,  2280,
+    2289,  2289,  2298,  2298,  2307,  2307,  2321,  2321,  2332,  2333,
+    2336,  2336,  2348,  2348,  2359,  2360,  2361,  2366,  2366,  2376,
+    2377,  2380,  2381,  2382,  2387,  2388,  2389,  2390,  2391,  2392,
+    2393,  2394,  2395,  2396,  2397,  2398,  2399,  2402,  2404,  2404,
+    2413,  2422,  2422,  2435,  2436,  2437,  2442,  2443,  2444,  2445,
+    2446,  2447,  2448,  2449,  2450,  2453,  2453,  2461,  2462,  2463,
+    2466,  2472,  2472,  2481,  2487,  2495,  2503,  2503,  2514,  2515,
+    2516,  2521,  2522,  2523,  2524,  2525,  2528,  2528,  2537,  2537,
+    2549,  2549,  2562,  2563,  2564,  2569,  2570,  2571,  2572,  2573,
+    2574,  2577,  2583,  2583,  2592,  2598,  2598,  2608,  2608,  2621,
+    2621,  2631,  2632,  2633,  2638,  2639,  2640,  2641,  2642,  2643,
+    2644,  2645,  2646,  2647,  2648,  2649,  2650,  2651,  2652,  2653,
+    2654,  2655,  2658,  2665,  2665,  2674,  2674,  2683,  2689,  2689,
+    2698,  2704,  2710,  2710,  2719,  2720,  2723,  2723,  2733,  2740,
+    2747,  2747,  2756,  2756,  2766,  2766,  2776,  2776,  2788,  2788,
+    2800,  2800,  2810,  2811,  2812,  2818,  2819,  2822,  2822,  2833,
+    2841,  2841,  2854,  2855,  2856,  2862,  2862,  2870,  2871,  2872,
+    2877,  2878,  2879,  2880,  2881,  2882,  2883,  2886,  2892,  2892,
+    2901,  2901,  2912,  2913,  2914,  2919,  2919,  2927,  2928,  2929,
+    2934,  2935,  2936,  2937,  2938,  2941,  2941,  2950,  2956,  2962,
+    2968,  2968,  2977,  2977,  2988,  2989,  2990,  2995,  2996,  2999
+  };
+
+  void
+  Dhcp6Parser::yy_stack_print_ () const
+  {
+    *yycdebug_ << "Stack now";
+    for (stack_type::const_iterator
+           i = yystack_.begin (),
+           i_end = yystack_.end ();
+         i != i_end; ++i)
+      *yycdebug_ << ' ' << int (i->state);
+    *yycdebug_ << '\n';
+  }
+
+  void
+  Dhcp6Parser::yy_reduce_print_ (int yyrule) const
+  {
+    int yylno = yyrline_[yyrule];
+    int yynrhs = yyr2_[yyrule];
+    // Print the symbols being reduced, and their result.
+    *yycdebug_ << "Reducing stack by rule " << yyrule - 1
+               << " (line " << yylno << "):\n";
+    // The symbols being reduced.
+    for (int yyi = 0; yyi < yynrhs; yyi++)
+      YY_SYMBOL_PRINT ("   $" << yyi + 1 << " =",
+                       yystack_[(yynrhs) - (yyi + 1)]);
+  }
+#endif // PARSER6_DEBUG
+
+
+#line 14 "dhcp6_parser.yy"
+} } // isc::dhcp
+#line 6350 "dhcp6_parser.cc"
+
+#line 3005 "dhcp6_parser.yy"
+
+
+void
+isc::dhcp::Dhcp6Parser::error(const location_type& loc,
+                              const std::string& what)
+{
+    ctx.error(loc, what);
+}