dhcp6_parser.cc

Go to the documentation of this file.

// 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"

  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;
    int yylen = 0;

    // Error handling.
    int yynerrs_ = 0;
    int yyerrstatus_ = 0;

    symbol_type yyla;

    stack_symbol_type yyerror_range[3];

    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"
                                    {
    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"
                                    {
    // 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"
                                    {
    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"
                                    {
    // 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