grammar.tab.c

一个编译器修改的例子

#  if defined __GNUC__ && 1 < __GNUC__
#   define YYCOPY(To, From, Count) \
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
#  else
#   define YYCOPY(To, From, Count)		\
      do					\
	{					\
	  YYSIZE_T yyi;				\
	  for (yyi = 0; yyi < (Count); yyi++)	\
	    (To)[yyi] = (From)[yyi];		\
	}					\
      while (YYID (0))
#  endif
# endif

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */
# define YYSTACK_RELOCATE(Stack)					\
    do									\
      {									\
	YYSIZE_T yynewbytes;						\
	YYCOPY (&yyptr->Stack, Stack, yysize);				\
	Stack = &yyptr->Stack;						\
	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
	yyptr += yynewbytes / sizeof (*yyptr);				\
      }									\
    while (YYID (0))

#endif

/* YYFINAL -- State number of the termination state.  */
#define YYFINAL  3
/* YYLAST -- Last index in YYTABLE.  */
#define YYLAST   679

/* YYNTOKENS -- Number of terminals.  */
#define YYNTOKENS  63
/* YYNNTS -- Number of nonterminals.  */
#define YYNNTS  39
/* YYNRULES -- Number of rules.  */
#define YYNRULES  98
/* YYNRULES -- Number of states.  */
#define YYNSTATES  183

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
#define YYUNDEFTOK  2
#define YYMAXUTOK   302

#define YYTRANSLATE(YYX)						\
  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
static const yytype_uint8 yytranslate[] =
{
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      56,    60,    50,    48,    61,    49,    57,    51,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,    59,    58,
      44,    42,    45,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,    39,     2,    62,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
      35,    36,    37,    38,    40,    41,    43,    46,    47,    52,
      53,    54,    55
};

#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
   YYRHS.  */
static const yytype_uint16 yyprhs[] =
{
       0,     0,     3,     4,     7,     9,    12,    14,    16,    18,
      24,    26,    29,    33,    35,    37,    42,    45,    46,    50,
      53,    57,    59,    63,    65,    68,    71,    74,    78,    82,
      84,    88,    90,    92,    94,    96,    98,   100,   102,   106,
     108,   110,   112,   114,   116,   118,   120,   122,   124,   129,
     130,   136,   140,   141,   144,   148,   151,   161,   162,   165,
     170,   177,   183,   186,   190,   195,   198,   202,   205,   208,
     212,   216,   220,   224,   228,   232,   236,   240,   244,   248,
     252,   256,   261,   265,   266,   272,   274,   276,   278,   280,
     282,   284,   286,   288,   296,   300,   301,   303,   305
};

/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
static const yytype_int8 yyrhs[] =
{
      64,     0,    -1,    -1,    65,    66,    -1,    67,    -1,    66,
      67,    -1,    70,    -1,    79,    -1,    68,    -1,    33,    69,
      18,    80,    12,    -1,    35,    -1,    71,    58,    -1,    71,
      18,    85,    -1,    72,    -1,    73,    -1,    15,    74,    59,
      83,    -1,    22,    74,    -1,    -1,    35,    75,    76,    -1,
      56,    60,    -1,    56,    77,    60,    -1,    78,    -1,    77,
      58,    78,    -1,    81,    -1,    31,    81,    -1,    31,    80,
      -1,    81,    58,    -1,    80,    81,    58,    -1,    82,    59,
      83,    -1,    35,    -1,    82,    61,    35,    -1,     6,    -1,
       8,    -1,    17,    -1,    23,    -1,    26,    -1,    84,    -1,
      35,    -1,     4,    21,    83,    -1,    86,    -1,    87,    -1,
      90,    -1,    91,    -1,    92,    -1,    94,    -1,    95,    -1,
      96,    -1,    97,    -1,    98,     3,    98,    58,    -1,    -1,
      88,    79,     5,    89,    12,    -1,     5,    89,    12,    -1,
      -1,    89,    85,    -1,     9,    98,    58,    -1,    98,    58,
      -1,    14,    98,     3,    98,    28,    98,    93,    10,    85,
      -1,    -1,     7,    98,    -1,    16,    98,    27,    85,    -1,
      16,    98,    27,    85,    11,    85,    -1,    24,    85,    30,
      98,    58,    -1,    25,    58,    -1,    25,    98,    58,    -1,
      32,    98,    10,    85,    -1,    55,    98,    -1,    54,    21,
      98,    -1,    49,    98,    -1,    48,    98,    -1,    98,    40,
      98,    -1,    98,    41,    98,    -1,    98,    42,    98,    -1,
      98,    43,    98,    -1,    98,    44,    98,    -1,    98,    47,
      98,    -1,    98,    45,    98,    -1,    98,    46,    98,    -1,
      98,    48,    98,    -1,    98,    49,    98,    -1,    98,    50,
      98,    -1,    98,    51,    98,    -1,    98,    39,    98,    62,
      -1,    56,    98,    60,    -1,    -1,    98,    56,    99,   100,
      60,    -1,    35,    -1,    29,    -1,    13,    -1,    34,    -1,
      36,    -1,    37,    -1,    38,    -1,    20,    -1,    19,     4,
      39,    98,    62,    21,    83,    -1,    98,    57,    35,    -1,
      -1,   101,    -1,    98,    -1,   101,    61,    98,    -1
};

/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
static const yytype_uint16 yyrline[] =
{
       0,   128,   128,   128,   149,   151,   162,   164,   166,   172,
     186,   198,   208,   225,   227,   233,   246,   258,   257,   278,
     284,   295,   297,   309,   311,   324,   334,   337,   349,   366,
     375,   390,   395,   400,   405,   410,   415,   417,   431,   442,
     444,   446,   448,   450,   452,   454,   456,   458,   464,   476,
     476,   488,   500,   504,   515,   526,   536,   555,   559,   569,
     577,   591,   604,   610,   621,   633,   639,   647,   654,   661,
     668,   675,   682,   689,   696,   703,   710,   717,   724,   731,
     738,   745,   753,   762,   760,   772,   778,   783,   788,   793,
     798,   803,   808,   813,   826,   836,   840,   846,   852
};
#endif

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "ASSIGNMENT", "ARRAY", "_BEGIN", "BOOL",
  "BY", "CHAR", "DELETE", "DO", "ELSE", "END", "FALSE", "FOR", "FUNCTION",
  "IF", "INT", "IS", "NEW", "__NULL", "OF", "PROCEDURE", "REAL", "REPEAT",
  "RETURN", "STRING", "THEN", "TO", "TRUE", "UNTIL", "VAR", "WHILE",
  "RECORD", "CHAR_CONSTANT", "IDENTIFIER", "INTEGER_CONSTANT",
  "REAL_CONSTANT", "STRING_CONSTANT", "'['", "OR", "AND", "'='",
  "NOT_EQUAL", "'<'", "'>'", "GREATER_EQUAL", "SMALLER_EQUAL", "'+'",
  "'-'", "'*'", "'/'", "UNARY_PLUS", "UNARY_MINUS", "SIZE", "NOT", "'('",
  "'.'", "';'", "':'", "')'", "','", "']'", "$accept", "program", "@1",
  "declarations", "declaration", "record_declaration", "identifier1",
  "subprogram_declaration", "subprogram_header", "function_header",
  "procedure_header", "name_and_argument_list", "@2", "formal_parameters",
  "formal_parameter_list", "formal_parameter", "var_declarations",
  "var_declaration_list", "var_declaration", "identifier_list", "type",
  "array_type", "statement", "assignment_statement", "compound_statement",
  "@3", "opt_statements", "delete_statement", "expression_statement",
  "for_statement", "opt_by_expression", "if_statement", "repeat_statement",
  "return_statement", "while_statement", "expression", "@4",
  "opt_actual_parameters", "actual_parameters", 0
};
#endif

# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
   token YYLEX-NUM.  */
static const yytype_uint16 yytoknum[] =
{
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
     285,   286,   287,   288,   289,   290,   291,   292,   293,    91,
     294,   295,    61,   296,    60,    62,   297,   298,    43,    45,
      42,    47,   299,   300,   301,   302,    40,    46,    59,    58,
      41,    44,    93
};
# endif

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
static const yytype_uint8 yyr1[] =
{
       0,    63,    65,    64,    66,    66,    67,    67,    67,    68,
      69,    70,    70,    71,    71,    72,    73,    75,    74,    76,
      76,    77,    77,    78,    78,    79,    80,    80,    81,    82,
      82,    83,    83,    83,    83,    83,    83,    83,    84,    85,
      85,    85,    85,    85,    85,    85,    85,    85,    86,    88,
      87,    87,    89,    89,    90,    91,    92,    93,    93,    94,
      94,    95,    96,    96,    97,    98,    98,    98,    98,    98,
      98,    98,    98,    98,    98,    98,    98,    98,    98,    98,
      98,    98,    98,    99,    98,    98,    98,    98,    98,    98,
      98,    98,    98,    98,    98,   100,   100,   101,   101
};

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
static const yytype_uint8 yyr2[] =
{
       0,     2,     0,     2,     1,     2,     1,     1,     1,     5,
       1,     2,     3,     1,     1,     4,     2,     0,     3,     2,
       3,     1,     3,     1,     2,     2,     2,     3,     3,     1,
       3,     1,     1,     1,     1,     1,     1,     1,     3,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     4,     0,
       5,     3,     0,     2,     3,     2,     9,     0,     2,     4,
       6,     5,     2,     3,     4,     2,     3,     2,     2,     3,
       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
       3,     4,     3,     0,     5,     1,     1,     1,     1,     1,
       1,     1,     1,     7,     3,     0,     1,     1,     3
};

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
   means the default is an error.  */
static const yytype_uint8 yydefact[] =
{
       2,     0,     0,     1,     0,     0,     0,     0,     3,     4,
       8,     6,     0,    13,    14,     7,    17,     0,    16,    29,
      25,     0,     0,    10,     0,     5,    49,    11,     0,     0,
       0,    26,     0,     0,     0,    52,     0,    87,     0,     0,
       0,    92,    49,     0,    86,     0,    88,    85,    89,    90,
      91,     0,     0,     0,     0,     0,    12,    39,    40,     0,
      41,    42,    43,    44,    45,    46,    47,     0,     0,    18,
       0,    31,    32,    33,    34,    35,    37,    15,    36,    27,
      28,    30,     0,    49,     0,     0,     0,     0,     0,    62,
       0,     0,    68,    67,     0,    65,     0,     0,     0,     0,
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
       0,     0,    83,     0,    55,     0,    19,     0,    21,    23,
       0,     9,    51,    53,    54,     0,    49,     0,     0,    63,
      49,    66,    82,    52,     0,     0,    69,    70,    71,    72,
      73,    75,    76,    74,    77,    78,    79,    80,    95,    94,
      24,     0,    20,    38,     0,    59,     0,     0,    64,    49,
      48,    81,    97,     0,    96,    22,     0,    49,     0,    61,
      50,    84,     0,    57,    60,     0,    98,     0,     0,    93,
      58,    49,    56
};

/* YYDEFGOTO[NTERM-NUM].  */
static const yytype_int16 yydefgoto[] =
{
      -1,     1,     2,     8,     9,    10,    24,    11,    12,    13,
      14,    17,    28,    69,   117,   118,    15,    20,    21,    22,
      77,    78,   123,    57,    58,    59,    83,    60,    61,    62,
     178,    63,    64,    65,    66,    67,   148,   163,   164
};

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
   STATE-NUM.  */
#define YYPACT_NINF -42
static const yytype_int16 yypact[] =
{
     -42,     7,    66,   -42,   -22,   -22,   -21,   -12,    66,   -42,
     -42,   -42,    -6,   -42,   -42,   -42,   -42,   -35,   -42,   -42,
     -21,   -24,   -32,   -42,    17,   -42,   268,   -42,    -3,     2,
      -4,   -42,     2,    20,   -21,   -42,   378,   -42,   378,   378,
      55,   -42,   268,   347,   -42,   378,   -42,   -42,   -42,   -42,
     -42,   378,   378,    42,   378,   378,   -42,   -42,   -42,    51,
     -42,   -42,   -42,   -42,   -42,   -42,   -42,     0,     1,   -42,
      62,   -42,   -42,   -42,   -42,   -42,   -42,   -42,   -42,   -42,
     -42,   -42,     3,   172,   509,   123,   396,    46,    56,   -42,
     529,   308,    23,    23,   378,    23,   487,    82,   378,   378,
     378,   378,   378,   378,   378,   378,   378,   378,   378,   378,
     378,   378,   -42,    63,   -42,   -21,   -42,   -27,   -42,   -42,
       2,   -42,   -42,   -42,   -42,   378,   268,   378,   378,   -42,
     268,    23,   -42,   -42,   549,   439,   608,    73,   101,   101,
     622,   622,   622,   622,    45,    45,    23,    23,   378,   -42,
     -42,    -9,   -42,   -42,   420,    79,   463,   569,   -42,   220,
     -42,   -42,   589,    43,    44,   -42,   378,   268,    85,   -42,
     -42,   -42,   378,   287,   -42,     2,   589,   378,    97,   -42,
     589,   268,   -42
};

/* YYPGOTO[NTERM-NUM].  */
static const yytype_int8 yypgoto[] =
{
     -42,   -42,   -42,   -42,   100,   -42,   -42,   -42,   -42,   -42,
     -42,   104,   -42,   -42,   -42,   -41,    52,    93,    10,   -42,
     -31,   -42,   -26,   -42,   -42,   -42,   -20,   -42,   -42,   -42,
     -42,   -42,   -42,   -42,   -42,   -34,   -42,   -42,   -42
};

/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
   positive, shift that token.  If negative, reduce the rule which
   number is the opposite.  If zero, do what YYDEFACT says.
   If YYTABLE_NINF, syntax error.  */
#define YYTABLE_NINF -1
static const yytype_int16 yytable[] =
{
      56,    80,    84,    98,    85,    86,    70,     3,    71,    90,
      72,    91,    26,    16,    19,   121,    88,    92,    93,    73,
      95,    96,   115,    23,    29,    74,    19,    32,    75,    33,
      30,   151,   115,   152,    31,    34,    19,    76,    19,    99,
     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
     110,   111,    27,    68,    79,    81,   112,   113,   114,    87,
     131,   116,    99,    94,   134,   135,   136,   137,   138,   139,
     140,   141,   142,   143,   144,   145,   146,   147,   119,   112,
     113,     4,     6,   120,    99,   127,   128,   133,     5,   153,
     167,   154,    30,   156,   157,   110,   111,     6,   149,     7,
     155,   112,   113,   171,   158,   172,   175,   181,    25,    18,
     165,    97,    99,   159,   162,   102,   103,   104,   105,   106,
     107,   108,   109,   110,   111,   150,   125,    82,     0,   112,
     113,     0,   173,     0,     0,     0,     0,     0,   176,     0,
      99,   174,     0,   180,   179,   104,   105,   106,   107,   108,
     109,   110,   111,     0,     0,   182,     0,   112,   113,     0,
       0,   119,    99,   100,   101,   102,   103,   104,   105,   106,
     107,   108,   109,   110,   111,     0,     0,    35,     0,   112,
     113,    36,     0,     0,   122,    37,    38,     0,    39,     0,
       0,    40,    41,     0,     0,     0,    42,    43,     0,     0,
       0,    44,     0,     0,    45,     0,    46,    47,    48,    49,
      50,     0,     0,     0,     0,     0,     0,     0,     0,     0,
      51,    52,     0,     0,     0,    35,    53,    54,    55,    36,
       0,     0,   170,    37,    38,     0,    39,     0,     0,    40,
      41,     0,     0,     0,    42,    43,     0,     0,     0,    44,
       0,     0,    45,     0,    46,    47,    48,    49,    50,     0,
       0,     0,     0,     0,     0,     0,     0,     0,    51,    52,
       0,     0,     0,    35,    53,    54,    55,    36,     0,     0,
       0,    37,    38,     0,    39,     0,     0,    40,    41,     0,
       0,     0,    42,    43,   177,     0,     0,    44,     0,     0,
      45,     0,    46,    47,    48,    49,    50,     0,     0,     0,
       0,     0,     0,     0,     0,     0,    51,    52,   130,     0,
       0,     0,    53,    54,    55,     0,    99,   100,   101,   102,
     103,   104,   105,   106,   107,   108,   109,   110,   111,     0,
       0,     0,     0,   112,   113,     0,     0,    99,   100,   101,
     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
      37,     0,     0,     0,   112,   113,    40,    41,     0,     0,
       0,     0,     0,     0,     0,     0,    44,     0,     0,     0,
       0,    46,    47,    48,    49,    50,     0,     0,     0,     0,
       0,    37,     0,     0,     0,    51,    52,    40,    41,     0,
       0,    53,    54,    55,     0,    89,     0,    44,     0,     0,
       0,     0,    46,    47,    48,    49,    50,     0,     0,     0,
       0,     0,     0,   126,     0,     0,    51,    52,     0,     0,
       0,     0,    53,    54,    55,    99,   100,   101,   102,   103,
     104,   105,   106,   107,   108,   109,   110,   111,   166,     0,
       0,     0,   112,   113,     0,     0,     0,     0,     0,    99,
     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
     110,   111,     0,     0,     0,     0,   112,   113,    99,   100,
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
     111,     0,     0,     0,     0,   112,   113,     0,     0,     0,
       0,   161,    99,   100,   101,   102,   103,   104,   105,   106,
     107,   108,   109,   110,   111,     0,     0,     0,     0,   112,
     113,     0,     0,     0,     0,   168,    99,   100,   101,   102,
     103,   104,   105,   106,   107,   108,   109,   110,   111,     0,
       0,     0,     0,   112,   113,     0,     0,   132,    99,   100,
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
     111,     0,     0,     0,     0,   112,   113,   124,    99,   100,
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
     111,     0,     0,     0,     0,   112,   113,   129,    99,   100,
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
     111,     0,     0,     0,     0,   112,   113,   160,    99,   100,
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
     111,     0,     0,     0,     0,   112,   113,   169,    99,   100,
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
     111,     0,     0,     0,     0,   112,   113,    99,     0,   101,
     102,   103,   104,   105,   106,   107,   108,   109,   110,   111,
       0,    99,     0,     0,   112,   113,    -1,    -1,    -1,    -1,
     108,   109,   110,   111,     0,     0,     0,     0,   112,   113
};

static const yytype_int16 yycheck[] =
{
      26,    32,    36,     3,    38,    39,     4,     0,     6,    43,
       8,    45,    18,    35,    35,    12,    42,    51,    52,    17,
      54,    55,    31,    35,    59,    23,    35,    59,    26,    61,
      20,    58,    31,    60,    58,    18,    35,    35,    35,    39,
      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
      50,    51,    58,    56,    58,    35,    56,    57,    58,     4,
      94,    60,    39,    21,    98,    99,   100,   101,   102,   103,
     104,   105,   106,   107,   108,   109,   110,   111,    68,    56,
      57,    15,    31,    21,    39,    39,    30,     5,    22,   120,
      11,   125,    82,   127,   128,    50,    51,    31,    35,    33,
     126,    56,    57,    60,   130,    61,    21,    10,     8,     5,
     151,    59,    39,   133,   148,    42,    43,    44,    45,    46,
      47,    48,    49,    50,    51,   115,     3,    34,    -1,    56,
      57,    -1,   166,    -1,    -1,    -1,    -1,    -1,   172,    -1,
      39,   167,    -1,   177,   175,    44,    45,    46,    47,    48,
      49,    50,    51,    -1,    -1,   181,    -1,    56,    57,    -1,
      -1,   151,    39,    40,    41,    42,    43,    44,    45,    46,
      47,    48,    49,    50,    51,    -1,    -1,     5,    -1,    56,
      57,     9,    -1,    -1,    12,    13,    14,    -1,    16,    -1,
      -1,    19,    20,    -1,    -1,    -1,    24,    25,    -1,    -1,
      -1,    29,    -1,    -1,    32,    -1,    34,    35,    36,    37,
      38,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
      48,    49,    -1,    -1,    -1,     5,    54,    55,    56,     9,
      -1,    -1,    12,    13,    14,    -1,    16,    -1,    -1,    19,
      20,    -1,    -1,    -1,    24,    25,    -1,    -1,    -1,    29,
      -1,    -1,    32,    -1,    34,    35,    36,    37,    38,    -1,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    48,    49,
      -1,    -1,    -1,     5,    54,    55,    56,     9,    -1,    -1,
      -1,    13,    14,    -1,    16,    -1,    -1,    19,    20,    -1,