sportdb-parser 0.6.19 → 0.7.0

data/lib/sportdb/parser/parser.rb

@@ -9,409 +9,588 @@ class RaccMatchParser < Racc::Parser
 ##### State transition tables begin ###
 
 racc_action_table = [
-    21,    13,    22,   101,   214,   227,   245,   106,    23,   176,
-    57,    24,    55,   247,   110,   230,    25,    97,    51,    26,
-    27,   121,    28,    58,   213,   106,    32,   174,    60,   231,
-    29,   221,    48,    30,    34,   226,    35,    36,    37,   107,
-    39,    42,    44,    45,    98,   100,    86,    21,    13,    22,
-   101,   177,    57,    53,    55,    23,   111,   107,    24,   256,
-   222,    57,   219,    25,   171,    51,    26,    27,    89,    28,
-    86,    67,    94,    32,    61,    66,    82,    29,    83,    48,
-    30,    34,    92,    35,    36,    37,    63,    39,    42,    44,
-    45,    98,   100,    86,    57,    70,    55,    70,   147,    57,
-    53,    55,   113,   146,    91,    70,   103,   250,   104,    72,
-    73,    72,    73,   248,    44,    45,   116,    51,   155,    72,
-    73,   231,   138,   152,   141,   144,   190,   147,   154,   140,
-   126,   150,   146,   147,   162,   163,   194,    77,   146,   130,
-   133,   131,   132,    67,   192,   193,    78,    66,   130,   133,
-   131,   132,    79,    80,    86,  -109,  -110,    87,    88,    48,
-   105,   117,   118,    57,   126,   127,   134,   136,   137,   142,
-   143,   148,   149,   158,   160,   164,   165,   167,   168,   -99,
-   169,    48,   178,   179,   181,   182,    51,   184,   126,   186,
-    57,   188,    57,   196,   197,   198,   199,   200,   201,   202,
-   203,   205,   206,   207,   208,    70,   210,   211,   212,    77,
-   216,   217,   219,   223,   224,   225,   228,    48,   232,   233,
-   179,   235,    57,   126,   237,   238,   239,   240,   241,   242,
-   243,   244,   249,    48,   252,   158,   254,    77,   257,   219,
-   259 ]
+    28,    21,    29,   270,    30,    31,    32,    33,    34,    35,
+    36,    37,    38,   250,   274,    39,    76,   342,    40,    41,
+    42,   280,    43,    44,    45,    48,   228,   249,   287,   250,
+   139,    86,    60,    61,    62,    63,   135,    64,    68,   250,
+    73,    74,    75,   249,   358,   324,   137,    88,   269,   250,
+   250,   357,   173,   249,    89,   175,   288,   257,   229,   275,
+    77,   140,   325,   249,   249,   136,   281,   356,    78,   280,
+    79,   272,    80,   285,  -160,    81,   138,   263,   278,    82,
+    83,    84,    85,    28,    21,    29,    90,    30,    31,    32,
+    33,    34,    35,    36,    37,    38,    91,   341,    39,    76,
+  -160,    40,    41,    42,    92,    43,    44,    45,    48,   247,
+   248,  -160,   125,   123,   281,    60,    61,    62,    63,   128,
+    64,    68,   216,    73,    74,    75,   283,   189,   178,   128,
+   371,   189,    98,    99,   266,   126,   -77,    73,    74,    75,
+   179,    93,   123,    77,   292,   126,   265,    68,   115,   103,
+   102,    78,   190,    79,    94,    80,   190,    68,    81,   260,
+   112,   113,    82,    83,    84,    85,    73,    74,    75,   116,
+   117,   118,   173,    95,   261,   175,   262,   155,   156,   157,
+   158,   160,   161,   162,   170,   293,   163,   164,   165,   166,
+   167,   168,   169,    42,   178,    43,    44,    45,   294,   295,
+   157,   158,   160,   161,   162,   170,   179,   163,   164,   165,
+   166,   167,   168,   169,   112,   113,   353,    96,    60,    61,
+    62,    63,   197,    64,    97,    68,   116,   117,   150,   116,
+   117,   118,   254,   318,   256,   319,   348,   350,   349,   203,
+   204,   112,   113,   112,   113,   314,  -169,   369,   370,   101,
+   105,   106,   108,   129,   129,   132,   133,   134,   141,    68,
+   149,   152,   153,   154,   182,   183,   186,   193,   193,   197,
+   199,   201,   205,   212,   213,   214,   217,    68,   220,   221,
+   224,   225,   226,   227,    68,   231,   232,   233,   234,   235,
+   236,   237,   238,   239,   240,   241,   242,   243,   244,   245,
+   175,   259,   267,   271,   276,   277,   282,   289,   292,   296,
+   298,   299,   129,   302,   303,   304,   305,   306,   307,   308,
+   175,   310,   311,   312,   175,   316,   320,   321,   322,   182,
+   326,   327,   328,   329,   186,   331,   333,   334,   335,   336,
+   193,   338,   339,   340,   197,   344,   345,   354,   359,   360,
+   256,   362,   363,   364,   365,   366,   367,   368,   372,   197,
+   374,   375,   376,   292,   378,   379 ]
 
 racc_action_check = [
-     0,     0,     0,    41,   152,   166,   219,    47,     0,    99,
-    53,     0,    53,   219,    48,   172,     0,    41,     0,     0,
-     0,    54,     0,     1,   152,    48,     0,    98,    22,   172,
-     0,   159,     0,     0,     0,   166,     0,     0,     0,    47,
-     0,     0,     0,     0,    41,    41,    41,     2,     2,     2,
-    95,    99,     0,     0,     0,     2,    48,    48,     2,   253,
-   159,    54,   253,     2,    95,     2,     2,     2,    38,     2,
-    98,    25,    38,     2,    23,    25,    32,     2,    32,     2,
-     2,     2,    38,     2,     2,     2,    24,     2,     2,     2,
-     2,    95,    95,    95,    32,    26,    32,    27,   220,     2,
-     2,     2,    49,   220,    38,   158,    42,   229,    42,    26,
-    26,    27,    27,   220,    42,    42,    49,    49,    75,   158,
-   158,   229,    64,    75,    64,    68,   124,    68,    75,    64,
-   124,    74,    68,    74,    79,    79,   128,    28,    74,   128,
-   128,   128,   128,   139,   126,   126,    29,   139,    60,    60,
-    60,    60,    30,    31,    33,    34,    35,    36,    37,    40,
-    45,    51,    52,    55,    57,    58,    61,    62,    63,    66,
-    67,    70,    71,    77,    78,    81,    84,    86,    90,    92,
-    93,    97,   100,   108,   109,   112,   114,   116,   117,   119,
-   120,   121,   123,   130,   131,   132,   133,   134,   135,   136,
-   138,   140,   141,   142,   144,   145,   147,   150,   151,   153,
-   154,   155,   156,   161,   164,   165,   168,   171,   175,   177,
-   182,   186,   187,   190,   196,   197,   198,   201,   202,   212,
-   213,   214,   227,   231,   244,   245,   246,   247,   255,   256,
-   258 ]
+     0,     0,     0,   184,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,   252,   187,     0,     0,   285,     0,     0,
+     0,   191,     0,     0,     0,     0,   141,   252,   195,   176,
+    62,     1,     0,     0,     0,     0,    60,     0,     0,   309,
+     0,     0,     0,   176,   297,   265,    61,    29,   184,   180,
+   172,   297,    77,   309,    30,    77,   195,   176,   141,   187,
+     0,    62,   265,   180,   172,    60,   191,   297,     0,   194,
+     0,   187,     0,   195,   252,     0,    61,   180,   191,     0,
+     0,     0,     0,     2,     2,     2,    31,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,    32,   285,     2,     2,
+   309,     2,     2,     2,    33,     2,     2,     2,     2,   172,
+   172,   172,    53,    52,   194,     2,     2,     2,     2,    53,
+     2,     2,   120,     2,     2,     2,   194,    82,    78,   120,
+   351,   273,    39,    39,   182,    53,   110,    52,    52,    52,
+    78,    34,   207,     2,   351,   120,   182,    53,    51,    41,
+    41,     2,    82,     2,    35,     2,   273,   120,     2,   179,
+   110,   110,     2,     2,     2,     2,   207,   207,   207,    51,
+    51,    51,   132,    36,   179,   132,   179,    76,    76,    76,
+    76,    76,    76,    76,    76,   200,    76,    76,    76,    76,
+    76,    76,    76,    65,   258,    65,    65,    65,   200,   200,
+   123,   123,   123,   123,   123,   123,   258,   123,   123,   123,
+   123,   123,   123,   123,    50,    50,   292,    37,   109,   109,
+   109,   109,   292,   109,    38,    50,    71,    71,    71,   122,
+   122,   122,   175,   259,   175,   259,   290,   290,   290,   104,
+   104,   127,   127,   218,   218,   253,   253,   348,   348,    40,
+    46,    48,    49,    54,    55,    56,    58,    59,    63,    66,
+    68,    73,    74,    75,    79,    80,    81,    83,    84,    85,
+    86,   100,   107,   111,   113,   115,   124,   126,   130,   131,
+   134,   135,   137,   139,   145,   148,   156,   159,   160,   161,
+   162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
+   173,   178,   183,   186,   189,   190,   193,   197,   198,   202,
+   210,   215,   219,   222,   224,   228,   229,   231,   237,   245,
+   246,   247,   248,   249,   251,   257,   261,   262,   263,   264,
+   266,   267,   268,   269,   270,   272,   274,   275,   276,   278,
+   279,   281,   283,   284,   286,   287,   288,   295,   302,   304,
+   315,   325,   326,   328,   329,   340,   341,   342,   352,   353,
+   356,   357,   368,   371,   373,   377 ]
 
 racc_action_pointer = [
-    -1,    23,    46,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    -1,    31,    82,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    24,    64,    71,    56,    80,    82,   122,   114,
-   120,   149,    41,   107,   122,   123,   153,   154,    64,   nil,
-   126,    -1,    71,   nil,   nil,   117,   nil,   -12,     6,    98,
-   nil,   108,   158,   -43,     8,   110,   nil,   142,   165,   nil,
-   143,   155,   154,   152,   111,   nil,   154,   154,   114,   nil,
-   149,   150,   nil,   nil,   120,   110,   nil,   146,   141,    99,
-   nil,   147,   nil,   nil,   148,   nil,   128,   nil,   nil,   nil,
-   140,   nil,   138,   139,   nil,    46,   nil,   148,    23,     5,
-   178,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   131,   151,
-   nil,   nil,   152,   nil,   167,   nil,   183,   166,   nil,   178,
-   137,   187,   nil,   139,   108,   nil,    88,   nil,   134,   nil,
-   187,   188,   189,   192,   193,   187,   185,   nil,   196,   128,
-   197,   198,   187,   nil,   200,   190,   nil,   202,   nil,   nil,
-   203,   197,     0,   194,   206,   207,   187,   nil,    90,    27,
-   nil,   209,   nil,   nil,   210,   211,   -13,   nil,   212,   nil,
-   nil,   184,    11,   nil,   nil,   214,   nil,   215,   nil,   nil,
-   nil,   nil,   168,   nil,   nil,   nil,   217,   169,   nil,   nil,
-   201,   nil,   nil,   nil,   nil,   nil,   220,   221,   222,   nil,
-   nil,   223,   218,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   225,   215,   207,   nil,   nil,   nil,   nil,    -9,
-    85,   nil,   nil,   nil,   nil,   nil,   nil,   183,   nil,   103,
-   nil,   200,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   219,   208,   210,   222,   nil,   nil,
-   nil,   nil,   nil,    37,   nil,   212,   214,   nil,   214,   nil ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    43,
+    50,    82,    92,   100,   137,   150,   169,   213,   220,   118,
+   245,   135,   nil,   nil,   nil,   nil,   246,   nil,   247,   250,
+   186,   118,    96,   108,   242,   243,   224,   nil,   252,   253,
+    32,    42,    26,   221,   nil,   172,   220,   nil,   220,   nil,
+   nil,   175,   nil,   244,   245,   246,   133,   -10,    75,   192,
+   191,   188,    74,   189,   190,   191,   270,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   254,   nil,   nil,   nil,   218,   nil,   nil,   270,   nil,   185,
+   132,   269,   nil,   246,   nil,   271,   nil,   nil,   nil,   nil,
+   118,   nil,   178,   154,   272,   nil,   238,   213,   nil,   nil,
+   274,   275,   110,   nil,   253,   248,   nil,   248,   nil,   248,
+   nil,    22,   nil,   nil,   nil,   245,   nil,   nil,   267,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   269,   nil,   nil,   270,
+   271,   272,   273,   274,   275,   276,   277,   278,   279,   280,
+   281,   267,    46,   235,   nil,   166,    25,   nil,   236,   106,
+    45,   nil,    81,   227,   -15,   nil,   224,    -4,   nil,   226,
+   226,     3,   nil,   234,    51,    10,   nil,   222,   222,   nil,
+   181,   nil,   305,   nil,   nil,   nil,   nil,   125,   nil,   nil,
+   306,   nil,   nil,   nil,   nil,   307,   nil,   nil,   215,   301,
+   nil,   nil,   281,   nil,   310,   nil,   nil,   nil,   279,   279,
+   nil,   277,   nil,   nil,   nil,   nil,   nil,   258,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   315,   255,   317,   318,   319,
+   nil,   259,     9,   178,   nil,   nil,   nil,   321,   141,   165,
+   nil,   273,   274,   324,   257,    -8,   265,   327,   257,   256,
+   256,   nil,   331,    78,   332,   333,   259,   nil,   335,   262,
+   nil,   337,   nil,   338,   268,    13,   266,   341,   342,   nil,
+   148,   nil,   144,   nil,   nil,   330,   nil,    40,   nil,   nil,
+   nil,   nil,   344,   nil,   312,   nil,   nil,   nil,   nil,    35,
+   nil,   nil,   nil,   nil,   nil,   282,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   298,   282,   nil,   349,   280,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   351,   278,   273,   nil,   nil,   nil,   nil,   nil,   158,   nil,
+   nil,    58,   271,   281,   nil,   nil,   356,   357,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   284,   nil,
+   nil,   277,   nil,   277,   nil,   nil,   nil,   278,   nil,   nil ]
 
 racc_action_default = [
-    -1,  -161,    -2,    -3,    -5,    -6,    -7,    -8,    -9,   -10,
+    -1,  -243,    -2,    -3,    -5,    -6,    -7,    -8,    -9,   -10,
    -11,   -12,   -13,   -14,   -15,   -16,   -17,   -18,   -19,   -20,
-   -21,   -22,  -161,  -161,  -161,  -161,  -161,  -161,  -161,  -161,
-  -161,  -161,  -161,   -86,   -88,   -89,  -161,  -161,  -161,   -96,
-  -161,  -161,  -106,  -108,  -111,  -112,  -124,  -125,  -161,  -161,
-  -136,  -161,  -161,  -161,  -146,  -161,  -151,  -161,  -161,    -4,
-  -161,  -161,   -32,   -34,  -161,   -37,  -161,   -45,  -161,   -49,
-   -54,   -74,   -76,   -77,  -161,   -57,   -60,   -67,  -161,  -161,
-   -84,  -161,   -88,   -89,  -161,   -87,  -161,   -90,   -91,   -92,
-  -161,   -94,   -95,  -161,   -98,  -161,  -101,  -161,  -161,  -161,
-  -161,  -119,  -107,  -109,  -110,  -113,  -129,  -130,  -131,  -161,
-  -127,  -128,  -161,  -135,  -161,  -138,  -139,  -141,  -144,  -161,
-  -161,  -149,  -152,  -147,  -153,  -154,  -157,   260,  -161,   -24,
-  -161,  -161,  -161,  -161,  -161,  -161,  -161,   -35,  -161,  -161,
-   -39,   -41,   -43,   -46,  -161,  -161,   -51,   -52,   -55,   -75,
-  -161,  -161,  -161,  -161,   -62,   -64,   -69,   -68,  -161,  -161,
-   -79,  -161,   -82,   -83,  -161,  -161,  -120,  -122,  -161,   -97,
-  -100,  -161,  -161,  -104,  -114,  -161,  -116,  -161,  -118,  -132,
-  -134,  -126,  -131,  -137,  -140,  -142,  -161,  -148,  -150,  -155,
-  -161,  -158,  -159,  -160,   -23,   -25,  -161,  -161,  -161,   -29,
-   -30,  -161,  -161,   -36,   -38,   -40,   -42,   -44,   -47,   -50,
-   -53,   -48,  -161,  -161,  -161,   -61,   -63,   -65,   -66,  -161,
-  -161,   -78,   -80,   -81,   -85,  -143,  -121,  -161,   -93,  -161,
-  -103,  -161,  -115,  -117,  -133,  -145,  -156,   -26,   -27,   -28,
-   -31,   -33,   -56,   -58,  -161,   -67,  -161,  -161,   -73,  -123,
-  -102,  -105,   -59,   -69,   -71,  -161,   -69,   -72,  -161,   -70 ]
+   -21,   -22,   -23,   -24,   -25,   -26,   -27,   -28,   -29,  -243,
+  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,
+  -243,  -243,   -52,   -53,   -54,   -55,   -56,   -57,  -243,   -63,
+  -115,  -121,  -243,  -243,   -80,   -80,  -120,   -89,  -243,  -243,
+  -243,  -243,  -243,  -243,  -106,   -58,  -115,  -110,  -243,  -122,
+  -123,  -124,  -125,  -243,  -243,  -243,  -243,  -243,  -243,  -243,
+  -243,  -243,  -243,  -243,  -243,  -243,  -243,    -4,   -30,   -31,
+   -32,   -33,   -34,   -35,   -36,   -37,   -38,   -39,   -40,   -41,
+  -243,   -46,   -47,   -48,  -243,   -61,   -62,   -64,   -65,  -104,
+  -116,  -243,   -75,  -243,  -108,  -243,  -137,  -138,  -148,  -149,
+  -243,  -120,  -121,  -243,  -243,   -85,  -111,   -77,  -114,   -81,
+  -243,  -243,  -243,   -90,   -92,  -243,   -98,  -243,   -99,  -243,
+  -100,  -243,   -56,   -59,   -60,  -115,  -109,  -116,  -117,  -118,
+  -150,  -151,  -126,  -127,  -128,  -129,  -243,  -131,  -132,  -243,
+  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,
+  -243,  -243,  -153,  -243,  -164,  -168,  -160,  -175,  -243,  -243,
+  -160,  -184,  -243,  -243,  -192,  -194,  -196,  -243,  -199,  -243,
+  -207,  -243,  -211,  -216,  -243,  -219,  -222,  -230,  -234,   380,
+  -243,   -43,  -243,   -50,   -51,   -66,   -67,  -243,   -69,  -105,
+  -243,   -78,   -74,   -76,   -79,  -243,   -83,   -84,   -77,   -80,
+   -86,   -87,  -243,   -91,  -243,   -94,   -95,   -96,  -243,  -243,
+  -107,  -243,  -130,  -133,  -134,  -135,  -136,  -139,  -140,  -141,
+  -142,  -143,  -144,  -145,  -147,  -243,  -243,  -156,  -158,  -161,
+  -163,  -243,  -154,  -166,  -167,  -171,  -173,  -243,  -243,  -177,
+  -180,  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,  -243,
+  -243,  -197,  -243,  -243,  -201,  -203,  -205,  -208,  -243,  -243,
+  -213,  -214,  -217,  -243,  -243,  -243,  -243,  -224,  -226,  -231,
+  -228,  -233,  -243,   -42,   -44,  -243,   -49,  -243,   -73,   -82,
+  -112,  -113,  -243,   -93,  -243,  -101,  -119,  -146,  -152,  -155,
+  -157,  -159,  -162,  -165,  -170,  -243,  -174,  -176,  -178,  -179,
+  -181,  -182,  -183,  -185,  -186,  -243,  -188,  -190,  -243,  -243,
+  -195,  -198,  -200,  -202,  -204,  -206,  -209,  -212,  -215,  -210,
+  -243,  -243,  -243,  -223,  -225,  -227,  -229,  -232,  -238,  -241,
+  -242,  -234,  -243,  -243,   -45,   -68,  -243,  -243,   -72,   -88,
+   -97,  -172,  -187,  -189,  -191,  -193,  -218,  -220,  -243,  -239,
+  -240,  -234,  -236,  -243,   -70,   -71,  -221,  -243,  -237,  -235 ]
 
 racc_goto_table = [
-    76,    95,   156,   125,   122,    65,    68,    74,   172,   180,
-   129,    85,   115,    96,   123,    84,     3,     1,    59,   108,
-   112,     2,   128,    62,   135,    64,   139,   209,    75,   151,
-   153,   258,   159,   161,    81,    90,   119,    93,   102,   166,
-   109,   114,   120,   124,   191,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   173,   nil,
-   nil,   nil,   nil,   185,   nil,   nil,   nil,   170,   nil,   nil,
-   189,   nil,   nil,   122,   nil,   nil,   175,   183,   195,   187,
-   nil,   nil,   229,   234,   nil,   nil,   nil,   nil,   nil,   nil,
+   196,   188,   185,   181,   177,   130,   131,   120,   122,   121,
+   255,   210,   252,   110,   114,   124,   127,   171,   258,     3,
+     1,    87,   264,   191,   194,     2,   100,   200,   219,   147,
+   146,   104,   202,   142,   144,   143,   145,   109,   107,   206,
+   207,   355,   208,   111,   223,   209,   148,   151,   246,   313,
+   253,   315,   176,   180,   184,   268,   187,   273,   337,   195,
+   284,   286,   347,   346,   290,   351,   377,   nil,   nil,   nil,
+   nil,   nil,   222,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   215,   127,   nil,   309,   nil,   nil,   nil,   218,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   147,   230,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   300,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   204,
-   nil,   nil,   nil,   nil,   nil,   215,   nil,   nil,   nil,   nil,
-   nil,   nil,   173,   nil,   nil,   nil,   236,   122,   220,   nil,
+   361,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   297,   122,   121,   nil,   nil,   nil,   nil,   nil,
+   301,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   317,   nil,   nil,   nil,   323,   nil,
+   nil,   330,   332,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   343,   nil,   nil,   nil,   nil,   nil,   352,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   253,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   246,   251,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   255 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   373 ]
 
 racc_goto_check = [
-    32,    47,    34,    60,    64,    25,    27,    27,    49,    56,
-    21,    42,    58,    48,    62,    61,     3,     1,     3,    55,
-    55,     2,    20,    22,    23,    24,    26,    28,    30,    31,
-    33,    35,    38,    39,    40,    44,    61,    45,    50,    51,
-    54,    59,    63,    65,    66,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    47,   nil,
-   nil,   nil,   nil,    60,   nil,   nil,   nil,    48,   nil,   nil,
-    60,   nil,   nil,    64,   nil,   nil,    42,    58,    21,    62,
-   nil,   nil,    49,    56,   nil,   nil,   nil,   nil,   nil,   nil,
+    90,    83,    81,    78,    76,    48,    48,    41,    47,    53,
+    74,    45,    68,    44,    60,    50,    44,    54,    70,     3,
+     1,     3,    70,    85,    85,     2,    27,    28,    45,    44,
+    60,    29,    30,    31,    33,    34,    35,    36,    37,    39,
+    40,    42,    43,    46,    57,    59,    61,    67,    69,    71,
+    72,    73,    75,    77,    79,    80,    82,    84,    86,    88,
+    89,    91,    92,    93,    94,    95,    96,   nil,   nil,   nil,
+   nil,   nil,    54,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    50,    44,   nil,    68,   nil,   nil,   nil,    44,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    44,    60,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    45,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    25,
-   nil,   nil,   nil,   nil,   nil,    32,   nil,   nil,   nil,   nil,
-   nil,   nil,    47,   nil,   nil,   nil,    60,    64,    27,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    74,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    41,    47,    53,   nil,   nil,   nil,   nil,   nil,
+    48,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    76,   nil,   nil,   nil,    78,   nil,
+   nil,    81,    83,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    90,   nil,   nil,   nil,   nil,   nil,    90,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-    34,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    32,    47,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    32 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    90 ]
 
 racc_goto_pointer = [
-   nil,    17,    21,    16,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    20,    25,    19,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   -38,   -50,    -1,   -38,     0,   -20,   -38,   -20,  -118,   nil,
-     0,   -46,   -28,   -45,   -75,  -225,   nil,   nil,   -46,   -46,
-     2,   nil,   -22,   nil,    -3,    -1,   nil,   -39,   -28,   -89,
-    -4,   -47,   nil,   nil,    -8,   -28,   -99,   nil,   -37,    -8,
-   -54,   -17,   -41,   -12,   -50,   -14,   -82 ]
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   -13,   -73,   -10,
+   -72,   -32,   nil,   -31,   -30,   -29,   -12,   -11,   nil,   -70,
+   -69,   -45,  -256,   -67,   -37,   -99,    -7,   -44,   -49,   nil,
+   -38,   nil,   nil,   -43,   -60,   nil,   nil,   -90,   nil,   -64,
+   -36,   -22,   nil,   nil,   nil,   nil,   nil,   -24,  -161,  -124,
+  -158,  -202,  -125,  -202,  -165,   -26,   -74,   -26,   -76,   -27,
+  -129,   -79,   -26,   -81,  -130,   -60,  -221,   nil,   -26,  -135,
+   -85,  -134,  -228,  -227,  -133,  -227,  -305 ]
 
 racc_goto_default = [
    nil,   nil,   nil,   nil,     4,     5,     6,     7,     8,     9,
-    10,    11,    12,    14,    15,    16,    17,    18,    19,    20,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    69,   145,
-   nil,   nil,   nil,   nil,   nil,   218,   157,    71,   nil,   nil,
-    31,    33,    99,    38,   nil,   nil,    40,    41,   nil,   nil,
-    43,   nil,    46,    47,   nil,   nil,   nil,    49,    50,   nil,
-   nil,    52,    54,   nil,    56,   nil,   nil ]
+    10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
+    20,    22,    23,    24,    25,    26,    27,   nil,   nil,   nil,
+   nil,    46,    47,    66,    50,   nil,   nil,   nil,    49,   nil,
+   nil,    53,   nil,    57,    67,   nil,   211,    51,   nil,    52,
+   nil,    54,    55,    56,   nil,    58,    59,   nil,   nil,    65,
+   nil,   nil,    69,    70,    71,    72,   159,   119,   172,   nil,
+   251,   174,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   192,   279,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   198,   291 ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
-  0, 59, :_reduce_none,
-  1, 59, :_reduce_none,
-  1, 60, :_reduce_none,
-  2, 60, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_14,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_none,
-  1, 61, :_reduce_22,
-  4, 71, :_reduce_none,
-  1, 78, :_reduce_none,
-  2, 78, :_reduce_none,
-  3, 79, :_reduce_26,
-  3, 79, :_reduce_27,
-  3, 79, :_reduce_28,
-  2, 79, :_reduce_none,
-  4, 77, :_reduce_30,
-  5, 76, :_reduce_31,
-  0, 81, :_reduce_none,
-  3, 81, :_reduce_33,
-  1, 80, :_reduce_34,
-  2, 80, :_reduce_35,
-  4, 75, :_reduce_36,
-  1, 82, :_reduce_37,
-  3, 82, :_reduce_38,
-  1, 84, :_reduce_none,
-  2, 84, :_reduce_none,
-  1, 84, :_reduce_none,
-  2, 84, :_reduce_none,
-  2, 83, :_reduce_43,
-  3, 83, :_reduce_44,
-  1, 83, :_reduce_45,
-  2, 83, :_reduce_46,
-  4, 73, :_reduce_47,
-  4, 74, :_reduce_48,
-  1, 85, :_reduce_49,
-  3, 85, :_reduce_50,
-  1, 87, :_reduce_none,
-  1, 87, :_reduce_none,
-  2, 87, :_reduce_none,
-  1, 86, :_reduce_54,
-  2, 86, :_reduce_55,
-  5, 72, :_reduce_56,
-  0, 89, :_reduce_57,
-  3, 89, :_reduce_58,
-  4, 89, :_reduce_59,
-  1, 88, :_reduce_60,
-  3, 88, :_reduce_61,
-  1, 91, :_reduce_none,
-  2, 91, :_reduce_63,
-  1, 91, :_reduce_none,
-  2, 91, :_reduce_65,
-  3, 90, :_reduce_66,
-  0, 92, :_reduce_67,
-  1, 92, :_reduce_68,
-  0, 93, :_reduce_69,
-  6, 93, :_reduce_70,
-  3, 93, :_reduce_71,
-  4, 93, :_reduce_72,
-  3, 94, :_reduce_73,
-  1, 85, :_reduce_74,
-  2, 85, :_reduce_75,
-  1, 95, :_reduce_none,
-  1, 95, :_reduce_none,
-  4, 66, :_reduce_78,
-  1, 96, :_reduce_79,
-  2, 96, :_reduce_80,
-  4, 67, :_reduce_81,
-  1, 97, :_reduce_82,
-  1, 97, :_reduce_83,
-  2, 62, :_reduce_84,
-  4, 62, :_reduce_85,
-  1, 98, :_reduce_none,
-  2, 98, :_reduce_87,
-  1, 99, :_reduce_88,
-  1, 99, :_reduce_89,
-  2, 63, :_reduce_90,
-  2, 65, :_reduce_91,
-  2, 64, :_reduce_92,
-  4, 64, :_reduce_93,
-  1, 102, :_reduce_none,
-  1, 102, :_reduce_none,
-  1, 101, :_reduce_96,
-  3, 101, :_reduce_97,
-  1, 103, :_reduce_none,
-  1, 103, :_reduce_none,
-  3, 68, :_reduce_100,
-  2, 68, :_reduce_101,
-  5, 68, :_reduce_102,
-  4, 68, :_reduce_103,
-  1, 107, :_reduce_104,
-  3, 107, :_reduce_105,
-  1, 104, :_reduce_106,
-  2, 104, :_reduce_107,
-  1, 104, :_reduce_none,
-  1, 108, :_reduce_109,
-  1, 108, :_reduce_110,
-  1, 108, :_reduce_111,
-  1, 108, :_reduce_112,
-  2, 108, :_reduce_113,
-  2, 106, :_reduce_114,
-  3, 106, :_reduce_115,
-  2, 106, :_reduce_116,
-  3, 106, :_reduce_117,
-  2, 106, :_reduce_118,
-  1, 106, :_reduce_119,
-  2, 100, :_reduce_120,
-  3, 100, :_reduce_121,
-  1, 109, :_reduce_122,
-  3, 109, :_reduce_123,
-  1, 105, :_reduce_none,
-  1, 105, :_reduce_none,
-  3, 111, :_reduce_126,
-  1, 112, :_reduce_none,
-  1, 112, :_reduce_none,
-  1, 113, :_reduce_none,
-  1, 113, :_reduce_none,
-  0, 114, :_reduce_131,
-  1, 114, :_reduce_132,
-  4, 110, :_reduce_133,
-  3, 110, :_reduce_134,
-  2, 70, :_reduce_135,
-  1, 115, :_reduce_136,
-  3, 115, :_reduce_137,
-  2, 115, :_reduce_138,
-  1, 117, :_reduce_none,
-  2, 117, :_reduce_none,
-  2, 116, :_reduce_141,
-  3, 116, :_reduce_142,
-  4, 69, :_reduce_143,
-  2, 69, :_reduce_144,
-  4, 69, :_reduce_145,
-  1, 119, :_reduce_146,
-  2, 119, :_reduce_147,
-  3, 119, :_reduce_148,
-  1, 121, :_reduce_none,
-  2, 121, :_reduce_none,
-  1, 120, :_reduce_151,
-  2, 120, :_reduce_152,
-  2, 122, :_reduce_153,
-  1, 123, :_reduce_154,
-  2, 123, :_reduce_155,
-  3, 123, :_reduce_156,
-  1, 118, :_reduce_157,
-  2, 118, :_reduce_158,
-  1, 124, :_reduce_159,
-  1, 124, :_reduce_160 ]
-
-racc_reduce_n = 161
-
-racc_shift_n = 260
+  0, 92, :_reduce_1,
+  1, 92, :_reduce_none,
+  1, 93, :_reduce_none,
+  2, 93, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_22,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_none,
+  1, 94, :_reduce_29,
+  2, 95, :_reduce_30,
+  2, 95, :_reduce_31,
+  2, 95, :_reduce_32,
+  2, 108, :_reduce_33,
+  2, 108, :_reduce_34,
+  2, 108, :_reduce_35,
+  2, 108, :_reduce_36,
+  2, 105, :_reduce_37,
+  2, 106, :_reduce_38,
+  2, 107, :_reduce_39,
+  1, 118, :_reduce_none,
+  1, 118, :_reduce_none,
+  4, 96, :_reduce_42,
+  1, 119, :_reduce_43,
+  2, 119, :_reduce_44,
+  3, 119, :_reduce_45,
+  2, 98, :_reduce_46,
+  1, 120, :_reduce_none,
+  1, 120, :_reduce_none,
+  4, 97, :_reduce_49,
+  1, 121, :_reduce_50,
+  1, 121, :_reduce_51,
+  1, 122, :_reduce_52,
+  1, 122, :_reduce_53,
+  1, 123, :_reduce_54,
+  1, 124, :_reduce_55,
+  1, 125, :_reduce_none,
+  1, 125, :_reduce_none,
+  0, 126, :_reduce_58,
+  1, 126, :_reduce_none,
+  1, 126, :_reduce_none,
+  2, 99, :_reduce_61,
+  2, 103, :_reduce_62,
+  0, 127, :_reduce_none,
+  1, 127, :_reduce_none,
+  1, 128, :_reduce_none,
+  2, 128, :_reduce_none,
+  3, 100, :_reduce_67,
+  3, 130, :_reduce_68,
+  1, 130, :_reduce_none,
+  2, 133, :_reduce_70,
+  2, 133, :_reduce_71,
+  1, 133, :_reduce_72,
+  4, 129, :_reduce_73,
+  3, 129, :_reduce_74,
+  1, 137, :_reduce_75,
+  2, 137, :_reduce_76,
+  0, 136, :_reduce_77,
+  1, 136, :_reduce_none,
+  3, 104, :_reduce_79,
+  0, 139, :_reduce_80,
+  1, 139, :_reduce_81,
+  4, 101, :_reduce_82,
+  3, 101, :_reduce_83,
+  3, 101, :_reduce_84,
+  2, 101, :_reduce_85,
+  3, 101, :_reduce_86,
+  3, 101, :_reduce_87,
+  5, 101, :_reduce_88,
+  1, 102, :_reduce_89,
+  2, 134, :_reduce_90,
+  3, 134, :_reduce_91,
+  0, 148, :_reduce_92,
+  2, 148, :_reduce_93,
+  3, 147, :_reduce_94,
+  3, 147, :_reduce_95,
+  3, 147, :_reduce_96,
+  5, 147, :_reduce_97,
+  2, 146, :_reduce_98,
+  2, 146, :_reduce_99,
+  2, 146, :_reduce_100,
+  4, 146, :_reduce_101,
+  0, 149, :_reduce_none,
+  1, 149, :_reduce_none,
+  0, 131, :_reduce_104,
+  1, 131, :_reduce_none,
+  1, 150, :_reduce_106,
+  3, 140, :_reduce_107,
+  2, 140, :_reduce_108,
+  2, 140, :_reduce_109,
+  1, 140, :_reduce_none,
+  1, 141, :_reduce_111,
+  3, 141, :_reduce_112,
+  3, 141, :_reduce_113,
+  1, 141, :_reduce_114,
+  0, 151, :_reduce_115,
+  1, 151, :_reduce_none,
+  2, 135, :_reduce_117,
+  1, 152, :_reduce_118,
+  3, 152, :_reduce_119,
+  1, 132, :_reduce_none,
+  1, 132, :_reduce_none,
+  1, 132, :_reduce_none,
+  1, 132, :_reduce_none,
+  1, 132, :_reduce_none,
+  1, 132, :_reduce_none,
+  2, 155, :_reduce_126,
+  2, 155, :_reduce_127,
+  2, 155, :_reduce_128,
+  2, 142, :_reduce_129,
+  3, 143, :_reduce_130,
+  1, 157, :_reduce_none,
+  1, 157, :_reduce_none,
+  3, 138, :_reduce_133,
+  3, 153, :_reduce_134,
+  3, 153, :_reduce_135,
+  3, 154, :_reduce_136,
+  1, 158, :_reduce_none,
+  1, 158, :_reduce_none,
+  3, 144, :_reduce_139,
+  3, 144, :_reduce_140,
+  3, 144, :_reduce_141,
+  3, 144, :_reduce_142,
+  3, 144, :_reduce_143,
+  3, 144, :_reduce_144,
+  3, 144, :_reduce_145,
+  4, 144, :_reduce_146,
+  3, 144, :_reduce_147,
+  2, 144, :_reduce_148,
+  2, 144, :_reduce_149,
+  2, 156, :_reduce_150,
+  2, 156, :_reduce_151,
+  4, 109, :_reduce_152,
+  1, 145, :_reduce_153,
+  2, 145, :_reduce_154,
+  3, 145, :_reduce_155,
+  1, 160, :_reduce_none,
+  2, 160, :_reduce_none,
+  1, 160, :_reduce_none,
+  2, 160, :_reduce_none,
+  0, 161, :_reduce_160,
+  1, 161, :_reduce_none,
+  2, 161, :_reduce_none,
+  1, 161, :_reduce_none,
+  1, 159, :_reduce_164,
+  3, 159, :_reduce_165,
+  2, 162, :_reduce_166,
+  2, 162, :_reduce_167,
+  1, 162, :_reduce_168,
+  0, 164, :_reduce_169,
+  1, 164, :_reduce_none,
+  1, 163, :_reduce_171,
+  3, 163, :_reduce_172,
+  1, 165, :_reduce_173,
+  4, 110, :_reduce_174,
+  1, 166, :_reduce_175,
+  3, 166, :_reduce_176,
+  2, 167, :_reduce_177,
+  3, 167, :_reduce_178,
+  3, 167, :_reduce_179,
+  2, 167, :_reduce_180,
+  3, 167, :_reduce_181,
+  3, 167, :_reduce_182,
+  4, 111, :_reduce_183,
+  1, 168, :_reduce_184,
+  3, 168, :_reduce_185,
+  3, 169, :_reduce_186,
+  4, 169, :_reduce_187,
+  3, 169, :_reduce_188,
+  4, 169, :_reduce_189,
+  4, 117, :_reduce_190,
+  5, 116, :_reduce_191,
+  0, 171, :_reduce_none,
+  3, 171, :_reduce_193,
+  1, 170, :_reduce_194,
+  3, 170, :_reduce_195,
+  1, 172, :_reduce_196,
+  2, 172, :_reduce_197,
+  4, 115, :_reduce_198,
+  1, 173, :_reduce_199,
+  3, 173, :_reduce_200,
+  1, 175, :_reduce_none,
+  2, 175, :_reduce_none,
+  1, 175, :_reduce_none,
+  2, 175, :_reduce_none,
+  2, 174, :_reduce_205,
+  3, 174, :_reduce_206,
+  1, 174, :_reduce_207,
+  2, 174, :_reduce_208,
+  4, 113, :_reduce_209,
+  4, 114, :_reduce_210,
+  1, 176, :_reduce_211,
+  3, 176, :_reduce_212,
+  1, 178, :_reduce_none,
+  1, 178, :_reduce_none,
+  2, 178, :_reduce_none,
+  1, 177, :_reduce_216,
+  2, 177, :_reduce_217,
+  5, 112, :_reduce_218,
+  0, 180, :_reduce_219,
+  3, 180, :_reduce_220,
+  4, 180, :_reduce_221,
+  1, 179, :_reduce_222,
+  3, 179, :_reduce_223,
+  1, 182, :_reduce_none,
+  2, 182, :_reduce_225,
+  1, 182, :_reduce_none,
+  2, 182, :_reduce_227,
+  0, 183, :_reduce_228,
+  1, 183, :_reduce_229,
+  0, 185, :_reduce_230,
+  1, 185, :_reduce_231,
+  3, 186, :_reduce_232,
+  2, 181, :_reduce_233,
+  0, 187, :_reduce_234,
+  5, 187, :_reduce_235,
+  3, 187, :_reduce_236,
+  4, 187, :_reduce_237,
+  1, 184, :_reduce_238,
+  2, 184, :_reduce_239,
+  2, 184, :_reduce_240,
+  1, 184, :_reduce_241,
+  1, 184, :_reduce_242 ]
+
+racc_reduce_n = 243
+
+racc_shift_n = 380
 
 racc_token_table = {
   false => 0,
   :error => 1,
   :BLANK => 2,
-  :TEAMS => 3,
+  :H1 => 3,
   :NEWLINE => 4,
-  "---" => 5,
-  :TEXT => 6,
-  "--" => 7,
-  "-" => 8,
-  :PROP_ATTENDANCE => 9,
-  :PROP_NUM => 10,
-  :PROP_END => 11,
-  :PROP_REFEREE => 12,
-  ";" => 13,
-  :ATTENDANCE => 14,
-  :PROP_NAME => 15,
-  :ENCLOSED_NAME => 16,
-  :PROP_PENALTIES => 17,
+  :H2 => 5,
+  :H3 => 6,
+  :TABLE_HEADING => 7,
+  :TABLE_LINE => 8,
+  :TABLE_NOTE => 9,
+  :TABLE_DIVIDER => 10,
+  :NOTE => 11,
+  :NOTA_BENE => 12,
+  :HRULER => 13,
+  "|" => 14,
+  ":" => 15,
+  :GROUP_DEF => 16,
+  :TEAM => 17,
   "," => 18,
-  :SCORE => 19,
-  :PROP_YELLOWCARDS => 20,
-  :PROP_REDCARDS => 21,
-  :MINUTE => 22,
-  :PROP => 23,
-  :COACH => 24,
-  "(" => 25,
-  ")" => 26,
-  "[" => 27,
-  "]" => 28,
-  :YELLOW_CARD => 29,
-  :RED_CARD => 30,
-  :GROUP_DEF => 31,
-  "|" => 32,
-  :TEAM => 33,
-  :ROUND_DEF => 34,
-  :DATE => 35,
-  :DURATION => 36,
-  :DATETIME => 37,
-  :GROUP => 38,
-  :ROUND_OUTLINE => 39,
-  "/" => 40,
-  :ROUND => 41,
-  :ORD => 42,
-  :TIME => 43,
-  :WDAY => 44,
-  :STATUS => 45,
-  :NOTE => 46,
-  "@" => 47,
-  :TIMEZONE => 48,
-  :GEO => 49,
-  :VS => 50,
-  :SCORE_MORE => 51,
-  :SCORE_NOTE => 52,
-  :PLAYER => 53,
-  :PROP_GOALS => 54,
-  :NONE => 55,
-  :OG => 56,
-  :PEN => 57 }
-
-racc_nt_base = 58
+  :ROUND_OUTLINE => 19,
+  :ROUND_DEF => 20,
+  :DATE => 21,
+  :DURATION => 22,
+  :YEAR => 23,
+  :DATETIME => 24,
+  :TIME => 25,
+  :DATE_LEGS => 26,
+  :STATUS => 27,
+  :INLINE_ATTENDANCE => 28,
+  :INLINE_ATTENDANCE_SEP => 29,
+  :SCORE_LEGS => 30,
+  :INLINE_GOALS => 31,
+  :GOALS_END => 32,
+  :TEAMALT => 33,
+  :TEAMALT_PEN => 34,
+  :TEAMALT_NUM => 35,
+  :TTY_TEXT => 36,
+  :TTY_NUM => 37,
+  :ORD => 38,
+  "@" => 39,
+  :GEO => 40,
+  :TEAM_HOME => 41,
+  :TEAM_AWAY => 42,
+  :TEAM_NEUTRAL => 43,
+  :INLINE_BYE => 44,
+  :INLINE_WO => 45,
+  "-" => 46,
+  :VS => 47,
+  :INLINE_NP => 48,
+  :INLINE_CANC => 49,
+  :INLINE_PPD => 50,
+  :SCORE_FULL => 51,
+  :SCORE_FULLER => 52,
+  :SCORE => 53,
+  :SCORE_AWD => 54,
+  :INLINE_AWD => 55,
+  :SCORE_ABD => 56,
+  :INLINE_ABD => 57,
+  :INLINE_VOID => 58,
+  :INLINE_SUSP => 59,
+  :SCORE_FULLER_MORE => 60,
+  :GOALS => 61,
+  :GOALS_NONE => 62,
+  ";" => 63,
+  :GOAL_SEP_ALT => 64,
+  :PLAYER => 65,
+  :GOAL_COUNT => 66,
+  :GOAL_MINUTE_SEP => 67,
+  :GOAL_MINUTE => 68,
+  :GOALS_ALT => 69,
+  :GOAL_TYPE => 70,
+  :GOALS_COMPAT => 71,
+  :MINUTE => 72,
+  :PROP_ATTENDANCE => 73,
+  :PROP_NUM => 74,
+  :PROP_END => 75,
+  :PROP_REFEREE => 76,
+  :ATTENDANCE => 77,
+  :PROP_NAME => 78,
+  :ENCLOSED_NAME => 79,
+  :PROP_PENALTIES => 80,
+  :PROP_YELLOWCARDS => 81,
+  :PROP_REDCARDS => 82,
+  :PROP => 83,
+  :COACH => 84,
+  :INLINE_CAPTAIN => 85,
+  "(" => 86,
+  ")" => 87,
+  :INLINE_YELLOW => 88,
+  :INLINE_YELLOW_RED => 89,
+  :INLINE_RED => 90 }
+
+racc_nt_base = 91
 
 racc_use_result_var = true
 
@@ -436,85 +615,176 @@ Racc_token_to_s_table = [
   "$end",
   "error",
   "BLANK",
-  "TEAMS",
+  "H1",
   "NEWLINE",
-  "\"---\"",
-  "TEXT",
-  "\"--\"",
+  "H2",
+  "H3",
+  "TABLE_HEADING",
+  "TABLE_LINE",
+  "TABLE_NOTE",
+  "TABLE_DIVIDER",
+  "NOTE",
+  "NOTA_BENE",
+  "HRULER",
+  "\"|\"",
+  "\":\"",
+  "GROUP_DEF",
+  "TEAM",
+  "\",\"",
+  "ROUND_OUTLINE",
+  "ROUND_DEF",
+  "DATE",
+  "DURATION",
+  "YEAR",
+  "DATETIME",
+  "TIME",
+  "DATE_LEGS",
+  "STATUS",
+  "INLINE_ATTENDANCE",
+  "INLINE_ATTENDANCE_SEP",
+  "SCORE_LEGS",
+  "INLINE_GOALS",
+  "GOALS_END",
+  "TEAMALT",
+  "TEAMALT_PEN",
+  "TEAMALT_NUM",
+  "TTY_TEXT",
+  "TTY_NUM",
+  "ORD",
+  "\"@\"",
+  "GEO",
+  "TEAM_HOME",
+  "TEAM_AWAY",
+  "TEAM_NEUTRAL",
+  "INLINE_BYE",
+  "INLINE_WO",
   "\"-\"",
+  "VS",
+  "INLINE_NP",
+  "INLINE_CANC",
+  "INLINE_PPD",
+  "SCORE_FULL",
+  "SCORE_FULLER",
+  "SCORE",
+  "SCORE_AWD",
+  "INLINE_AWD",
+  "SCORE_ABD",
+  "INLINE_ABD",
+  "INLINE_VOID",
+  "INLINE_SUSP",
+  "SCORE_FULLER_MORE",
+  "GOALS",
+  "GOALS_NONE",
+  "\";\"",
+  "GOAL_SEP_ALT",
+  "PLAYER",
+  "GOAL_COUNT",
+  "GOAL_MINUTE_SEP",
+  "GOAL_MINUTE",
+  "GOALS_ALT",
+  "GOAL_TYPE",
+  "GOALS_COMPAT",
+  "MINUTE",
   "PROP_ATTENDANCE",
   "PROP_NUM",
   "PROP_END",
   "PROP_REFEREE",
-  "\";\"",
   "ATTENDANCE",
   "PROP_NAME",
   "ENCLOSED_NAME",
   "PROP_PENALTIES",
-  "\",\"",
-  "SCORE",
   "PROP_YELLOWCARDS",
   "PROP_REDCARDS",
-  "MINUTE",
   "PROP",
   "COACH",
+  "INLINE_CAPTAIN",
   "\"(\"",
   "\")\"",
-  "\"[\"",
-  "\"]\"",
-  "YELLOW_CARD",
-  "RED_CARD",
-  "GROUP_DEF",
-  "\"|\"",
-  "TEAM",
-  "ROUND_DEF",
-  "DATE",
-  "DURATION",
-  "DATETIME",
-  "GROUP",
-  "ROUND_OUTLINE",
-  "\"/\"",
-  "ROUND",
-  "ORD",
-  "TIME",
-  "WDAY",
-  "STATUS",
-  "NOTE",
-  "\"@\"",
-  "TIMEZONE",
-  "GEO",
-  "VS",
-  "SCORE_MORE",
-  "SCORE_NOTE",
-  "PLAYER",
-  "PROP_GOALS",
-  "NONE",
-  "OG",
-  "PEN",
+  "INLINE_YELLOW",
+  "INLINE_YELLOW_RED",
+  "INLINE_RED",
   "$start",
   "document",
   "elements",
   "element",
-  "date_header",
-  "group_header",
-  "round_header",
-  "round_outline",
+  "heading",
   "group_def",
   "round_def",
+  "round_outline",
+  "date_header",
+  "match_line_with_header",
   "match_line",
+  "match_line_alt",
+  "date_header_legs",
+  "match_line_legs",
+  "note_line",
+  "nota_bene",
+  "hruler",
+  "table_line",
   "goal_lines",
   "goal_lines_alt",
-  "teams_list",
+  "goal_lines_compat",
   "lineup_lines",
   "yellowcard_lines",
   "redcard_lines",
   "penalties_lines",
   "referee_line",
   "attendance_line",
-  "list",
-  "list_item",
-  "referee",
+  "group_def_sep",
+  "team_values",
+  "round_def_sep",
+  "round_date_opts",
+  "date",
+  "datetime",
+  "time",
+  "date_clause",
+  "opt_date",
+  "opt_blank_lines",
+  "blank_lines",
+  "match_header",
+  "match_line_header",
+  "opt_ord",
+  "match",
+  "more_match_header_opts",
+  "match_line_alt_props",
+  "geo_opts",
+  "opt_inline_attendance",
+  "inline_attendance",
+  "match_fixture",
+  "opt_inline_note",
+  "match_opts",
+  "more_match_opts",
+  "match_bye",
+  "match_walkover",
+  "match_result",
+  "goal_lines_body",
+  "match_alt_inline",
+  "match_alt_block",
+  "opt_status_line",
+  "opt_newline",
+  "ord",
+  "opt_geo",
+  "geo_values",
+  "match_fixture_not_played",
+  "match_fixture_postponed",
+  "match_fixture_base",
+  "match_result_base",
+  "match_sep",
+  "score_full_or_fuller",
+  "goals",
+  "goals_sep",
+  "opt_goal_sep",
+  "goal",
+  "goal_minutes",
+  "opt_goal_minute_sep",
+  "goal_minute",
+  "goals_alt",
+  "goal_alt",
+  "goals_compat",
+  "goal_compat",
+  "referees",
   "attendance_opt",
+  "referee",
   "penalties_body",
   "penalty",
   "penalty_sep",
@@ -525,39 +795,11 @@ Racc_token_to_s_table = [
   "coach_opt",
   "lineup_name",
   "lineup_sep",
-  "lineup_card_opts",
-  "lineup_sub_opts",
-  "card",
-  "card_type",
-  "team_values",
-  "round_date_opts",
-  "date_header_body",
-  "date_header_date",
-  "geo_opts",
-  "round_values",
-  "group_sep",
-  "round_sep",
-  "match_opts",
-  "match",
-  "more_match_opts",
-  "more_matches",
-  "date_opts",
-  "geo_values",
-  "match_result",
-  "match_fixture",
-  "match_sep",
-  "score",
-  "score_note_opt",
-  "goals_alt",
-  "goal_alt",
-  "goal_alt_sep",
-  "minute",
-  "goal_lines_body",
-  "goals",
-  "goal_sep",
-  "goal",
-  "minutes",
-  "minute_opts" ]
+  "lineup_cards_opts",
+  "cards",
+  "lineup_captain_opt",
+  "lineup_name_plus_cards_opts",
+  "lineup_sub_opts" ]
 Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
 
 Racc_debug_parser = false
@@ -566,7 +808,12 @@ Racc_debug_parser = false
 
 # reduce 0 omitted
 
-# reduce 1 omitted
+module_eval(<<'.,.,', 'parser.y', 18)
+  def _reduce_1(val, _values, result)
+    
+    result
+  end
+.,.,
 
 # reduce 2 omitted
 
@@ -592,12 +839,7 @@ Racc_debug_parser = false
 
 # reduce 13 omitted
 
-module_eval(<<'.,.,', 'parser.y', 38)
-  def _reduce_14(val, _values, result)
-     trace( "REDUCE BLANK" )
-    result
-  end
-.,.,
+# reduce 14 omitted
 
 # reduce 15 omitted
 
@@ -613,12 +855,10 @@ module_eval(<<'.,.,', 'parser.y', 38)
 
 # reduce 21 omitted
 
-module_eval(<<'.,.,', 'parser.y', 47)
+module_eval(<<'.,.,', 'parser.y', 57)
   def _reduce_22(val, _values, result)
-     puts "!! skipping invalid content (trying to recover from parse error):"
-                pp val[0]
-                ##  note - do NOT report recover errors for now 
-                ##  @errors << "parser error (recover) - skipping #{val[0].pretty_inspect}"
+                   trace( "REDUCE BLANK" ) 
+               @tree << BlankLine.new
 
     result
   end
@@ -630,684 +870,759 @@ module_eval(<<'.,.,', 'parser.y', 47)
 
 # reduce 25 omitted
 
-module_eval(<<'.,.,', 'parser.y', 63)
-  def _reduce_26(val, _values, result)
-      puts "level 3"
-    result
-  end
-.,.,
+# reduce 26 omitted
 
-module_eval(<<'.,.,', 'parser.y', 64)
-  def _reduce_27(val, _values, result)
-      puts "level 2 #{val[1]}"
-    result
-  end
-.,.,
+# reduce 27 omitted
+
+# reduce 28 omitted
+
+module_eval(<<'.,.,', 'parser.y', 67)
+  def _reduce_29(val, _values, result)
+     puts "!! skipping invalid content (trying to recover from parse error):"
+                pp val[0]
+                ##  note - do NOT report recover errors for now 
+                ##  @errors << "parser error (recover) - skipping #{val[0].pretty_inspect}"
 
-module_eval(<<'.,.,', 'parser.y', 65)
-  def _reduce_28(val, _values, result)
-      puts "level 1 #{val[1]}"
     result
   end
 .,.,
 
-# reduce 29 omitted
-
-module_eval(<<'.,.,', 'parser.y', 71)
+module_eval(<<'.,.,', 'parser.y', 79)
   def _reduce_30(val, _values, result)
-                                     @tree << AttendanceLine.new( att: val[1][1][:value] )
-
+      @tree << Heading1.new( text: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 77)
+module_eval(<<'.,.,', 'parser.y', 80)
   def _reduce_31(val, _values, result)
-                                   kwargs = val[1] 
-                               @tree << RefereeLine.new( **kwargs ) 
-
+      @tree << Heading2.new( text: val[0])
     result
   end
 .,.,
 
-# reduce 32 omitted
+module_eval(<<'.,.,', 'parser.y', 81)
+  def _reduce_32(val, _values, result)
+      @tree << Heading3.new( text: val[0])
+    result
+  end
+.,.,
 
 module_eval(<<'.,.,', 'parser.y', 84)
   def _reduce_33(val, _values, result)
-                                     @tree << AttendanceLine.new( att: val[2][1][:value] )
-
+     @tree << TableHeading.new( text: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 89)
+module_eval(<<'.,.,', 'parser.y', 85)
   def _reduce_34(val, _values, result)
-      result = { name: val[0]}
+     @tree << TableLine.new( text: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 91)
+module_eval(<<'.,.,', 'parser.y', 86)
   def _reduce_35(val, _values, result)
-      result = { name: val[0], country: val[1] }
+     @tree << TableNote.new( text: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 96)
+module_eval(<<'.,.,', 'parser.y', 87)
   def _reduce_36(val, _values, result)
-                                   @tree << PenaltiesLine.new( penalties: val[1] )                                                            
-
+     @tree << TableDivider.new( text: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 99)
+module_eval(<<'.,.,', 'parser.y', 90)
   def _reduce_37(val, _values, result)
-      result = [val[0]]
+     @tree << NoteLine.new( text: val[0])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 100)
+module_eval(<<'.,.,', 'parser.y', 93)
   def _reduce_38(val, _values, result)
-      result << val[2]
+     @tree << NotaBene.new( text: val[0])
     result
   end
 .,.,
 
-# reduce 39 omitted
+module_eval(<<'.,.,', 'parser.y', 96)
+  def _reduce_39(val, _values, result)
+     @tree << HRuler.new
+    result
+  end
+.,.,
 
 # reduce 40 omitted
 
 # reduce 41 omitted
 
-# reduce 42 omitted
+module_eval(<<'.,.,', 'parser.y', 108)
+  def _reduce_42(val, _values, result)
+                          @tree << GroupDef.new( name:  val[0],
+                                             teams: val[2] )
+
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 110)
+module_eval(<<'.,.,', 'parser.y', 113)
   def _reduce_43(val, _values, result)
-                                     result = Penalty.new( score: val[0][1],
-                                                       name: val[1] )
+     result = val
+                                               ## e.g. val is ["Austria"] 
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 115)
+module_eval(<<'.,.,', 'parser.y', 116)
   def _reduce_44(val, _values, result)
-                                     result = Penalty.new( score: val[0][1],
-                                                       name: val[1],
-                                                       note: val[2] )
-
+     result.push( val[1] )
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 121)
+module_eval(<<'.,.,', 'parser.y', 117)
   def _reduce_45(val, _values, result)
-                                     result = Penalty.new( name: val[0] )                                
-
+     result.push( val[2] )
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 125)
   def _reduce_46(val, _values, result)
-                                     result = Penalty.new( name: val[0],
-                                                       note: val[1] )                                
+                                      kwargs = val[0][1]
+                                  @tree << RoundOutline.new( **kwargs )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 132)
-  def _reduce_47(val, _values, result)
-                                   @tree << CardsLine.new( type: 'Y', bookings: val[1] )                               
+# reduce 47 omitted
 
-    result
-  end
-.,.,
+# reduce 48 omitted
 
-module_eval(<<'.,.,', 'parser.y', 136)
-  def _reduce_48(val, _values, result)
-                                   @tree << CardsLine.new( type: 'R', bookings: val[1] )                    
+module_eval(<<'.,.,', 'parser.y', 142)
+  def _reduce_49(val, _values, result)
+                          kwargs = { name: val[0] }.merge( val[2] )
+                      @tree << RoundDef.new( **kwargs )
 
-    result
-  end
-.,.,
+                      ## auto-add RoundOutline here - why? why not?
+                      ##    or handle "implicit" round_outline
+                      ##     in tree walker?
+                      @tree << RoundOutline.new( outline: val[0], level: 1 )
 
-module_eval(<<'.,.,', 'parser.y', 143)
-  def _reduce_49(val, _values, result)
-       result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 145)
+module_eval(<<'.,.,', 'parser.y', 151)
   def _reduce_50(val, _values, result)
-      result << val[2]
+     result = { date: val[0][1] }
     result
   end
 .,.,
 
-# reduce 51 omitted
-
-# reduce 52 omitted
-
-# reduce 53 omitted
-
 module_eval(<<'.,.,', 'parser.y', 152)
-  def _reduce_54(val, _values, result)
-     result = Booking.new( name: val[0] )
+  def _reduce_51(val, _values, result)
+     result = { duration: val[0][1] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 154)
-  def _reduce_55(val, _values, result)
-     result = Booking.new( name: val[0], minute: val[1][1] )
+module_eval(<<'.,.,', 'parser.y', 159)
+  def _reduce_52(val, _values, result)
+     result = { date: val[0][1] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 162)
-  def _reduce_56(val, _values, result)
-                              kwargs = { team:    val[0],
-                                     lineup:  val[1]  }.merge( val[2] ) 
-                          @tree << LineupLine.new( **kwargs ) 
-
+module_eval(<<'.,.,', 'parser.y', 160)
+  def _reduce_53(val, _values, result)
+     result = { year: val[0] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 168)
-  def _reduce_57(val, _values, result)
-     result = {}
+module_eval(<<'.,.,', 'parser.y', 163)
+  def _reduce_54(val, _values, result)
+     result = {}.merge( val[0][1] )
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 170)
-  def _reduce_58(val, _values, result)
-      result = { coach: val[2] }
+module_eval(<<'.,.,', 'parser.y', 166)
+  def _reduce_55(val, _values, result)
+     result = {}.merge( val[0][1] )
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 172)
-  def _reduce_59(val, _values, result)
-      result = { coach: val[3] }
-    result
-  end
-.,.,
+# reduce 56 omitted
 
-module_eval(<<'.,.,', 'parser.y', 175)
-  def _reduce_60(val, _values, result)
-     result = [[val[0]]]
+# reduce 57 omitted
+
+module_eval(<<'.,.,', 'parser.y', 176)
+  def _reduce_58(val, _values, result)
+      result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 178)
+# reduce 59 omitted
+
+# reduce 60 omitted
+
+module_eval(<<'.,.,', 'parser.y', 189)
   def _reduce_61(val, _values, result)
-                           ## if lineup_sep is -  start a new sub array!!
-                       if val[1] == '-'
-                          result << [val[2]]
-                       else
-                          result[-1] << val[2]
-                       end
+                         @tree <<  DateHeader.new( **val[0] )  
 
     result
   end
 .,.,
 
-# reduce 62 omitted
+module_eval(<<'.,.,', 'parser.y', 195)
+  def _reduce_62(val, _values, result)
+                         kwargs =  val[0][1]  
+                     @tree <<  DateHeaderLegs.new( **kwargs )                      
 
-module_eval(<<'.,.,', 'parser.y', 188)
-  def _reduce_63(val, _values, result)
-     result = val[0]
     result
   end
 .,.,
 
-# reduce 64 omitted
+# reduce 63 omitted
 
-module_eval(<<'.,.,', 'parser.y', 190)
-  def _reduce_65(val, _values, result)
-     result = val[0]
-    result
-  end
-.,.,
+# reduce 64 omitted
 
-module_eval(<<'.,.,', 'parser.y', 195)
-  def _reduce_66(val, _values, result)
-                                  kwargs = { name: val[0] }.merge( val[1] ).merge( val[2] )
-                              result = Lineup.new( **kwargs )
+# reduce 65 omitted
 
-    result
-  end
-.,.,
+# reduce 66 omitted
 
-module_eval(<<'.,.,', 'parser.y', 199)
+module_eval(<<'.,.,', 'parser.y', 215)
   def _reduce_67(val, _values, result)
-     result = {}
+                         ## note - header flag (header: true)
+                     ##    used downstream for scope / e.g. DateHeader merge/inheritance or such                     
+                      kwargs = { header: true }.merge( val[0], val[2] )
+                      @tree << MatchLine.new( **kwargs )  
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 200)
+module_eval(<<'.,.,', 'parser.y', 224)
   def _reduce_68(val, _values, result)
-     result = { card: val[0] }
-    result
-  end
-.,.,
+                          result = {}.merge( val[0], val[1], val[2] )
 
-module_eval(<<'.,.,', 'parser.y', 217)
-  def _reduce_69(val, _values, result)
-     result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 220)
+# reduce 69 omitted
+
+module_eval(<<'.,.,', 'parser.y', 240)
   def _reduce_70(val, _values, result)
-                                  kwargs = { name: val[1] }.merge( val[2] ).merge( val[4] )
-                              sub    = Sub.new( sub:    Lineup.new( **kwargs ),
-                                                minute: Minute.new(val[3][1]) 
-                                              )
-                              result = { sub: sub }
+                          result = {}.merge( val[0][1] )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 228)
+module_eval(<<'.,.,', 'parser.y', 242)
   def _reduce_71(val, _values, result)
-                                  sub = Sub.new( sub: val[1] )
-                              result = { sub: sub }
-
+     result = { note: val[0] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 234)
+module_eval(<<'.,.,', 'parser.y', 243)
   def _reduce_72(val, _values, result)
-                                  sub = Sub.new( sub:    val[2],
-                                             minute: Minute.new(val[1][1]) 
-                                            )
-                              result = { sub: sub }
-
+     result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 244)
+module_eval(<<'.,.,', 'parser.y', 256)
   def _reduce_73(val, _values, result)
-                                  kwargs = val[1]
-                              result = Card.new( **kwargs )
+                          result = {}.merge( val[0], val[1], val[2] ) 
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 249)
+module_eval(<<'.,.,', 'parser.y', 260)
   def _reduce_74(val, _values, result)
-     result = { name: val[0] }
+                          result = {}.merge( val[0], val[1] ) 
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 252)
+module_eval(<<'.,.,', 'parser.y', 271)
   def _reduce_75(val, _values, result)
-     result = { name: val[0],
-                                        minute: Minute.new(val[1][1]) } 
+                           result = { att: val[0][1][:value] }
 
     result
   end
 .,.,
 
-# reduce 76 omitted
-
-# reduce 77 omitted
+module_eval(<<'.,.,', 'parser.y', 276)
+  def _reduce_76(val, _values, result)
+                           result = { att: val[1][1][:value] }
 
-module_eval(<<'.,.,', 'parser.y', 266)
-  def _reduce_78(val, _values, result)
-                          @tree << GroupDef.new( name:  val[0],
-                                             teams: val[2] )
+    result
+  end
+.,.,
 
+module_eval(<<'.,.,', 'parser.y', 280)
+  def _reduce_77(val, _values, result)
+      result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 272)
+# reduce 78 omitted
+
+module_eval(<<'.,.,', 'parser.y', 292)
   def _reduce_79(val, _values, result)
-                                                   result = val
-                                               ## e.g. val is ["Austria"] 
+                          kwargs = { score: val[1][1] }.merge( val[0] )
+                      @tree << MatchLineLegs.new( **kwargs )             
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 276)
+module_eval(<<'.,.,', 'parser.y', 298)
   def _reduce_80(val, _values, result)
-                                                   result.push( val[1] )
-
+      result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 285)
+module_eval(<<'.,.,', 'parser.y', 299)
   def _reduce_81(val, _values, result)
-                          kwargs = { name: val[0] }.merge( val[2] )
-                      @tree<< RoundDef.new( **kwargs )
-
+      result = { note: val[0] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 290)
+module_eval(<<'.,.,', 'parser.y', 307)
   def _reduce_82(val, _values, result)
-     result = { date: val[0][1] }
+                           kwargs = {}.merge( val[0], val[1], val[2] )
+                       @tree << MatchLine.new( **kwargs )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 291)
+module_eval(<<'.,.,', 'parser.y', 312)
   def _reduce_83(val, _values, result)
-     result = { duration: val[0][1] }
+                           kwargs = {}.merge( val[0], val[1])
+                       @tree << MatchLine.new( **kwargs )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 297)
+module_eval(<<'.,.,', 'parser.y', 317)
   def _reduce_84(val, _values, result)
-                         kwargs = {}.merge( val[0] )
-                     @tree <<  DateHeader.new( **kwargs )  
+                           kwargs = {}.merge( val[0], val[1] )
+                       @tree << MatchLine.new( **kwargs )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 302)
+module_eval(<<'.,.,', 'parser.y', 322)
   def _reduce_85(val, _values, result)
-                         kwargs = {}.merge( val[1] )
-                     @tree <<  DateHeader.new( **kwargs )  
+                           kwargs = {}.merge( val[0] )
+                       @tree << MatchLine.new( **kwargs )
 
     result
   end
 .,.,
 
-# reduce 86 omitted
+module_eval(<<'.,.,', 'parser.y', 328)
+  def _reduce_86(val, _values, result)
+                             kwargs = {}.merge( val[0], val[1] )
+                         @tree << MatchLineBye.new( **kwargs ) 
+
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 308)
+module_eval(<<'.,.,', 'parser.y', 333)
   def _reduce_87(val, _values, result)
-      result = {}.merge( val[0], val[1] )
+                             kwargs = {}.merge( val[0], val[1] )
+                         @tree << MatchLineWalkover.new( **kwargs )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 311)
+module_eval(<<'.,.,', 'parser.y', 344)
   def _reduce_88(val, _values, result)
-       result = { date: val[0][1]}
+                          kwargs = {}.merge( val[0] )
+                      @tree << MatchLine.new( **kwargs )
+
+                      kwargs = val[2]
+                      @tree << GoalLine.new( **kwargs ) 
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 312)
+module_eval(<<'.,.,', 'parser.y', 355)
   def _reduce_89(val, _values, result)
-       result = {}.merge( val[0][1] )
+                                 kwargs = {}.merge( val[0] )
+                             @tree << MatchLine.new( **kwargs )                           
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 319)
+module_eval(<<'.,.,', 'parser.y', 364)
   def _reduce_90(val, _values, result)
-                         @tree <<  GroupHeader.new( name: val[0] )  
+                                      result = {}.merge( val[0] )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 329)
+module_eval(<<'.,.,', 'parser.y', 368)
   def _reduce_91(val, _values, result)
-                                      @tree << RoundOutline.new( outline: val[0] )
+                                   result = {}.merge( val[0], val[2] )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 338)
+module_eval(<<'.,.,', 'parser.y', 374)
   def _reduce_92(val, _values, result)
-                         @tree <<  RoundHeader.new( names: val[0] )  
-
+     result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 342)
+module_eval(<<'.,.,', 'parser.y', 377)
   def _reduce_93(val, _values, result)
-                        @tree <<  RoundHeader.new( names: val[0], group: val[2] )  
+                          puts "status_line:"
+                      pp val[0]
+                      result = val[0][1]   
 
     result
   end
 .,.,
 
-# reduce 94 omitted
+module_eval(<<'.,.,', 'parser.y', 390)
+  def _reduce_94(val, _values, result)
+                               ## puts "debug match_alt reduce:"
+                           ## pp val[0]
+                           ## pp val[2]
 
-# reduce 95 omitted
+                           ## assume ht/ft  
+                           ## or let's use [[0,1],[1,2]] - why? why not?
+                           score_team1 = val[0][1][:score]
+                           score_team2 = val[2][1][:score]
+
+  
+                           score =  [[score_team1[0], score_team2[0]],
+                                     [score_team1[1], score_team2[1]]] 
+
+                           result = { team1: val[0][1][:team], 
+                                      team2: val[2][1][:team],
+                                      score: score
+                                    }
+
+                           ## puts "  result:"
+                           ## pp result   
 
-module_eval(<<'.,.,', 'parser.y', 347)
-  def _reduce_96(val, _values, result)
-      result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 348)
-  def _reduce_97(val, _values, result)
-       result.push( val[2] )
+module_eval(<<'.,.,', 'parser.y', 413)
+  def _reduce_95(val, _values, result)
+                               ## assume pen for score_ii
+                           ##    score_i might be ft or et???
+                           ## or let's use [[0,1],[1,2]] - why? why not?
+                           score_team1 = val[0][1][:score]
+                           score_team2 = val[2][1][:score]
+  
+                           score =  { '_': [score_team1[0], score_team2[0]],
+                                      pen: [score_team1[1], score_team2[1]] 
+                                    } 
+
+                           result = { team1: val[0][1][:team], 
+                                      team2: val[2][1][:team],
+                                      score: score
+                                    }   
+
     result
   end
 .,.,
 
-# reduce 98 omitted
+module_eval(<<'.,.,', 'parser.y', 430)
+  def _reduce_96(val, _values, result)
+                               score_team1 = val[0][1][:score]
+                           score_team2 = val[2][1][:score]
+  
+                           score =  [score_team1, score_team2] 
+
+                           result = { team1: val[0][1][:team], 
+                                      team2: val[2][1][:team],
+                                      score: score
+                                    }
 
-# reduce 99 omitted
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 358)
-  def _reduce_100(val, _values, result)
-                           kwargs = {}.merge( val[0], val[1], val[2] )
-                       @tree << MatchLine.new( **kwargs )
+module_eval(<<'.,.,', 'parser.y', 442)
+  def _reduce_97(val, _values, result)
+                               result = { team1: val[0], 
+                                      team2: val[3],
+                                      score: [val[1], val[4]]
+                                    }
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 363)
-  def _reduce_101(val, _values, result)
-                          kwargs = {}.merge( val[0], val[1] )
-                      @tree << MatchLine.new( **kwargs )
+module_eval(<<'.,.,', 'parser.y', 456)
+  def _reduce_98(val, _values, result)
+                               ## assume ht/ft  
+                           ## or let's use [[0,1],[1,2]] - why? why not?
+                           score_team1 = val[0][1][:score]
+                           score_team2 = val[1][1][:score]
+
+                           score =  [[score_team1[0], score_team2[0]],
+                                     [score_team1[1], score_team2[1]]] 
+
+                           result = { team1: val[0][1][:team], 
+                                      team2: val[1][1][:team],
+                                      score: score
+                                    }
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 371)
-  def _reduce_102(val, _values, result)
-                          kwargs = {}.merge( val[0], val[1] )
-                      @tree << MatchLine.new( **kwargs )
-                     
-                      ## add more match fixtures
-                      val[3].each do |kwargs|
-                         @tree << MatchLine.new( **kwargs)
-                      end
+module_eval(<<'.,.,', 'parser.y', 471)
+  def _reduce_99(val, _values, result)
+                               ## assume pen for score_ii
+                           ##    score_i might be ft or et???
+                           ## or let's use [[0,1],[1,2]] - why? why not?
+                           score_team1 = val[0][1][:score]
+                           score_team2 = val[1][1][:score]
+  
+                           score =  { '_': [score_team1[0], score_team2[0]],
+                                      pen: [score_team1[1], score_team2[1]] 
+                                    } 
+
+                           result = { team1: val[0][1][:team], 
+                                      team2: val[1][1][:team],
+                                      score: score
+                                    }   
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 381)
-  def _reduce_103(val, _values, result)
-                          kwargs = val[0]
-                      @tree << MatchLine.new( **kwargs )
- 
-                      ## add more match fixtures
-                      val[2].each do |kwargs|
-                         @tree << MatchLine.new( **kwargs)
-                      end
+module_eval(<<'.,.,', 'parser.y', 488)
+  def _reduce_100(val, _values, result)
+                               score_team1 = val[0][1][:score]
+                           score_team2 = val[1][1][:score]
+  
+                           score =  [score_team1, score_team2] 
+
+                           result = { team1: val[0][1][:team], 
+                                      team2: val[1][1][:team],
+                                      score: score
+                                    }
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 395)
-  def _reduce_104(val, _values, result)
-                                        trace( "REDUCE => more_matches : match" ) 
-                                    result = val
+module_eval(<<'.,.,', 'parser.y', 500)
+  def _reduce_101(val, _values, result)
+                               result = { team1: val[0], 
+                                      team2: val[2],
+                                      score: [val[1], val[3]]
+                                    }
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 400)
-  def _reduce_105(val, _values, result)
-                                         trace( "REDUCE => more_matches : more_matches ',' match" ) 
-                                     result.push( val[2] )
+# reduce 102 omitted
+
+# reduce 103 omitted
 
+module_eval(<<'.,.,', 'parser.y', 513)
+  def _reduce_104(val, _values, result)
+      result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 406)
+# reduce 105 omitted
+
+module_eval(<<'.,.,', 'parser.y', 517)
   def _reduce_106(val, _values, result)
-       result = { ord: val[0][1][:value] }
+      result = { num: val[0][1][:value] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 407)
+module_eval(<<'.,.,', 'parser.y', 522)
   def _reduce_107(val, _values, result)
-       result = { ord: val[0][1][:value] }.merge( val[1] )
+                                         result = {}.merge( val[0], val[1], val[2] )
+
     result
   end
 .,.,
 
-# reduce 108 omitted
+module_eval(<<'.,.,', 'parser.y', 525)
+  def _reduce_108(val, _values, result)
+                                         result = {}.merge( val[0], val[1] )
 
-module_eval(<<'.,.,', 'parser.y', 411)
-  def _reduce_109(val, _values, result)
-       result = { date: val[0][1]}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 412)
-  def _reduce_110(val, _values, result)
-       result = {}.merge( val[0][1] )
+module_eval(<<'.,.,', 'parser.y', 528)
+  def _reduce_109(val, _values, result)
+                                         result = {}.merge( val[0], val[1] )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 413)
+# reduce 110 omitted
+
+module_eval(<<'.,.,', 'parser.y', 549)
   def _reduce_111(val, _values, result)
-       result = { time: val[0][1]}
+                          result = {}.merge( val[0][1] ) 
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 414)
+module_eval(<<'.,.,', 'parser.y', 553)
   def _reduce_112(val, _values, result)
-       result = { wday: val[0][1]}
+                         result = {}.merge( val[0][1], val[1], val[2] ) 
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 415)
+module_eval(<<'.,.,', 'parser.y', 557)
   def _reduce_113(val, _values, result)
-       result = { wday: val[0][1], time: val[1][1] }
+                       result = {}.merge( val[0], val[1], val[2] ) 
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 429)
+module_eval(<<'.,.,', 'parser.y', 559)
   def _reduce_114(val, _values, result)
-                          ## todo - add possible status_notes too!!! 
-                      result = { status: val[0][1][:status] }
-
+     result = { note: val[0] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 434)
+module_eval(<<'.,.,', 'parser.y', 564)
   def _reduce_115(val, _values, result)
-                         result = { status: val[0][1][:status] }.merge( val[1] ) 
-
+     result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 436)
-  def _reduce_116(val, _values, result)
-     result = {}.merge( val[0] )
-    result
-  end
-.,.,
+# reduce 116 omitted
 
-module_eval(<<'.,.,', 'parser.y', 437)
+module_eval(<<'.,.,', 'parser.y', 570)
   def _reduce_117(val, _values, result)
-     result = { note: val[1] }.merge( val[0] )
+     result = { geo: val[1] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 438)
+module_eval(<<'.,.,', 'parser.y', 573)
   def _reduce_118(val, _values, result)
-     result = { note: val[0] }
+      result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 441)
+module_eval(<<'.,.,', 'parser.y', 574)
   def _reduce_119(val, _values, result)
-     result = {}
+      result.push( val[2] )
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 447)
-  def _reduce_120(val, _values, result)
-     result = { geo: val[1] }
+# reduce 120 omitted
+
+# reduce 121 omitted
+
+# reduce 122 omitted
+
+# reduce 123 omitted
+
+# reduce 124 omitted
+
+# reduce 125 omitted
+
+module_eval(<<'.,.,', 'parser.y', 597)
+  def _reduce_126(val, _values, result)
+     result = { team1: '_', team2: val[1] }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 448)
-  def _reduce_121(val, _values, result)
-     result = { geo: val[1], timezone: val[2] }
+module_eval(<<'.,.,', 'parser.y', 598)
+  def _reduce_127(val, _values, result)
+     result = { team1: val[1], team2: '_' }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 451)
-  def _reduce_122(val, _values, result)
-      result = val
+module_eval(<<'.,.,', 'parser.y', 599)
+  def _reduce_128(val, _values, result)
+     result = { team1: '_', team2: val[1],
+                                                       neutral: true }
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 452)
-  def _reduce_123(val, _values, result)
-      result.push( val[2] )
+module_eval(<<'.,.,', 'parser.y', 607)
+  def _reduce_129(val, _values, result)
+                          result = { team: val[0] }
+
     result
   end
 .,.,
 
-# reduce 124 omitted
+module_eval(<<'.,.,', 'parser.y', 616)
+  def _reduce_130(val, _values, result)
+                          result = { team1: val[0],
+                                 team2: val[2] }
 
-# reduce 125 omitted
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 460)
-  def _reduce_126(val, _values, result)
+# reduce 131 omitted
+
+# reduce 132 omitted
+
+module_eval(<<'.,.,', 'parser.y', 626)
+  def _reduce_133(val, _values, result)
                                    trace( "RECUDE match_fixture" )
                                result = { team1: val[0],
                                           team2: val[2] }   
@@ -1316,123 +1631,206 @@ module_eval(<<'.,.,', 'parser.y', 460)
   end
 .,.,
 
-# reduce 127 omitted
+module_eval(<<'.,.,', 'parser.y', 635)
+  def _reduce_134(val, _values, result)
+                                   ## note - auto-add (match) status canceled - why? why not?
+                               ##   A n/p B   short (inline) form of =>
+                               ##   A v B [canceled]
 
-# reduce 128 omitted
+                               result = { team1: val[0],
+                                          team2: val[2],
+                                          status_inline: 'canceled' }   
 
-# reduce 129 omitted
+    result
+  end
+.,.,
 
-# reduce 130 omitted
+module_eval(<<'.,.,', 'parser.y', 645)
+  def _reduce_135(val, _values, result)
+                                   result = { team1: val[0],
+                                          team2: val[2],
+                                          status_inline: 'canceled' }   
 
-module_eval(<<'.,.,', 'parser.y', 472)
-  def _reduce_131(val, _values, result)
-     result = {}
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 473)
-  def _reduce_132(val, _values, result)
-     result = { score_note: val[0] }
+module_eval(<<'.,.,', 'parser.y', 652)
+  def _reduce_136(val, _values, result)
+                                   result = { team1: val[0],
+                                          team2: val[2],
+                                          status_inline: 'postponed' }   
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 478)
-  def _reduce_133(val, _values, result)
-                               trace( "REDUCE => match_result : TEAM score TEAM" )
-                           result = { team1: val[0],
-                                      team2: val[2],
-                                      score: val[1][1]
-                                    }.merge( val[3] )   
+# reduce 137 omitted
+
+# reduce 138 omitted
+
+module_eval(<<'.,.,', 'parser.y', 668)
+  def _reduce_139(val, _values, result)
+                               trace( "REDUCE => match_result : TEAM SCORE TEAM" )
+ 
+                          ## note - use/keep generic score (as array!! NOT hash!!!)
+                           result = { team1: val[0], team2: val[2],
+                                      score: val[1][1][:score]  ## note - as array e.g. [1,1] !!
+                                    }   
                            ## pp result
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 487)
-  def _reduce_134(val, _values, result)
-                              trace( "REDUCE  => match_result : match_fixture score" )
-                          result = { score: val[1][1] }.merge( val[0] ).merge( val[2] )  
-                          ## pp result
+module_eval(<<'.,.,', 'parser.y', 678)
+  def _reduce_140(val, _values, result)
+                               result = { team1: val[0], team2: val[2],
+                                      score: val[1][1],
+                                      status_inline: 'awarded'
+                                    }                          
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 513)
-  def _reduce_135(val, _values, result)
-                                 @tree << GoalLineAlt.new( goals: val[0] )
+module_eval(<<'.,.,', 'parser.y', 685)
+  def _reduce_141(val, _values, result)
+                               result = { team1: val[0], team2: val[2], 
+                                      status_inline: 'awarded' 
+                                    }                          
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 517)
-  def _reduce_136(val, _values, result)
-     result = val
+module_eval(<<'.,.,', 'parser.y', 691)
+  def _reduce_142(val, _values, result)
+                               result = { team1: val[0], team2: val[2],
+                                      score: val[1][1],
+                                      status_inline: 'abandoned'
+                                    }                          
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 519)
-  def _reduce_137(val, _values, result)
-     result.push( val[2])
+module_eval(<<'.,.,', 'parser.y', 698)
+  def _reduce_143(val, _values, result)
+                               result = { team1: val[0], team2: val[2], 
+                                      status_inline: 'abandoned' 
+                                    }                          
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 521)
-  def _reduce_138(val, _values, result)
-     result.push( val[1])
+module_eval(<<'.,.,', 'parser.y', 704)
+  def _reduce_144(val, _values, result)
+                               result = { team1: val[0], team2: val[2], 
+                                      status_inline: 'annulled' 
+                                    }                          
+
     result
   end
 .,.,
 
-# reduce 139 omitted
+module_eval(<<'.,.,', 'parser.y', 710)
+  def _reduce_145(val, _values, result)
+                               result = { team1: val[0], team2: val[2], 
+                                      status_inline: 'suspended' 
+                                    }                          
 
-# reduce 140 omitted
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 529)
-  def _reduce_141(val, _values, result)
-                               result = GoalAlt.new( score:   val[0],
-                                                 player:  val[1] )
+module_eval(<<'.,.,', 'parser.y', 717)
+  def _reduce_146(val, _values, result)
+                                trace( "REDUCE => match_result : TEAM SCORE TEAM SCORE_FULLER_MORE" )
+                            score = nil
+                            score =  if val[3][1][:score] && 
+                                        val[3][1][:score]=='et'   ## check aet flag present? 
+                                         val[3][1].delete( :score )  ## note - remove/delete  flag
+                                           { et: val[1][1][:score] }
+                                     elsif val[3][1][:score] && 
+                                           val[3][1][:score]=='ht' ## check ht flag present?
+                                         val[3][1].delete( :score ) ## note - remove/delete flag
+                                           { ht: val[1][1][:score] }      
+                                     elsif val[3][1][:score] && 
+                                           val[3][1][:score]=='ft'  ## check ft flag present?
+                                         val[3][1].delete( :score )  ## note - remove/delete flag
+                                           { ft: val[1][1][:score] }
+                                     else   ## assume full-time (ft)
+                                            { ft: val[1][1][:score] }
+                                     end 
+
+                           result = {  team1: val[0],
+                                      team2: val[2],
+                                      score: score.merge( val[3][1] )
+                                    }                                    
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 534)
-  def _reduce_142(val, _values, result)
-                               result = GoalAlt.new( score:  val[0],
-                                                 player: val[1],
-                                                 minute: val[2] )
+module_eval(<<'.,.,', 'parser.y', 742)
+  def _reduce_147(val, _values, result)
+                               result = { team1: val[0],
+                                      team2: val[2],
+                                      score: val[1][1]
+                                    }                          
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 546)
-  def _reduce_143(val, _values, result)
-                           kwargs = val[1]
-                       @tree << GoalLine.new( **kwargs )
+module_eval(<<'.,.,', 'parser.y', 749)
+  def _reduce_148(val, _values, result)
+                              trace( "REDUCE  => match_result : match_fixture SCORE" )
+                          ## note - use/keep generic score (as array!! NOT hash!!!)
+                          result = { score: val[1][1][:score]  ## note - as array e.g. [1,1] !! 
+                                   }.merge( val[0] )  
+                          ## pp result
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 551)
-  def _reduce_144(val, _values, result)
-                             kwargs = val[0]
-                         @tree << GoalLine.new( **kwargs )
+module_eval(<<'.,.,', 'parser.y', 757)
+  def _reduce_149(val, _values, result)
+                              trace( "REDUCE  => match_result : match_fixture score" )
+                          result = { score: val[1][1] }.merge( val[0] )  
+                          ## pp result
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 556)
-  def _reduce_145(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 766)
+  def _reduce_150(val, _values, result)
+                              trace( "REDUCE  => match_result_base : match_fixture_base SCORE" )
+                          ## note - use/keep generic score (as array!! NOT hash!!!)
+                          result = { score: val[1][1][:score]  ## note - as array e.g. [1,1] !! 
+                                   }.merge( val[0] )  
+                          ## pp result
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 774)
+  def _reduce_151(val, _values, result)
+                              trace( "REDUCE  => match_result_base : match_fixture_base score" )
+                          result = { score: val[1][1] }.merge( val[0] )  
+                          ## pp result
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 813)
+  def _reduce_152(val, _values, result)
                              kwargs = val[1]
                          @tree << GoalLine.new( **kwargs )
 
@@ -1440,8 +1838,8 @@ module_eval(<<'.,.,', 'parser.y', 556)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 561)
-  def _reduce_146(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 818)
+  def _reduce_153(val, _values, result)
       result = { goals1: val[0],
                                                               goals2: [] } 
 
@@ -1449,8 +1847,8 @@ module_eval(<<'.,.,', 'parser.y', 561)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 564)
-  def _reduce_147(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 821)
+  def _reduce_154(val, _values, result)
       result = { goals1: [],
                                                               goals2: val[1] } 
 
@@ -1458,8 +1856,8 @@ module_eval(<<'.,.,', 'parser.y', 564)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 567)
-  def _reduce_148(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 824)
+  def _reduce_155(val, _values, result)
       result = { goals1: val[0],
                                                               goals2: val[2] }
 
@@ -1467,82 +1865,610 @@ module_eval(<<'.,.,', 'parser.y', 567)
   end
 .,.,
 
-# reduce 149 omitted
+# reduce 156 omitted
 
-# reduce 150 omitted
+# reduce 157 omitted
 
-module_eval(<<'.,.,', 'parser.y', 583)
-  def _reduce_151(val, _values, result)
+# reduce 158 omitted
+
+# reduce 159 omitted
+
+module_eval(<<'.,.,', 'parser.y', 835)
+  def _reduce_160(val, _values, result)
+    
+    result
+  end
+.,.,
+
+# reduce 161 omitted
+
+# reduce 162 omitted
+
+# reduce 163 omitted
+
+module_eval(<<'.,.,', 'parser.y', 840)
+  def _reduce_164(val, _values, result)
      result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 584)
-  def _reduce_152(val, _values, result)
-     result.push( val[1])
+module_eval(<<'.,.,', 'parser.y', 841)
+  def _reduce_165(val, _values, result)
+     result.push( val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 600)
-  def _reduce_153(val, _values, result)
-                      result = Goal.new( player:  val[0],
-                                     minutes: val[1] )   
+module_eval(<<'.,.,', 'parser.y', 849)
+  def _reduce_166(val, _values, result)
+                           result = Goal.new( player:  val[0],
+                                          minutes: val[1] )   
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 612)
-  def _reduce_154(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 854)
+  def _reduce_167(val, _values, result)
+                            ### todo/check:
+                        ##    auto convert/expand 
+                        ##    count to minutes - why? why not?
+                        ##  todo/fix - pass in empty minutes ary [] - why? why not?
+                        result = Goal.new( player: val[0],
+                                           count:  val[1][1] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 863)
+  def _reduce_168(val, _values, result)
+                            result = Goal.new( player: val[0],
+                                           minutes: [] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 870)
+  def _reduce_169(val, _values, result)
+    
+    result
+  end
+.,.,
+
+# reduce 170 omitted
+
+module_eval(<<'.,.,', 'parser.y', 873)
+  def _reduce_171(val, _values, result)
+      result = val
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 874)
+  def _reduce_172(val, _values, result)
+      result.push( val[2])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 878)
+  def _reduce_173(val, _values, result)
+                                 kwargs = {}.merge( val[0][1] )
+                             result = GoalMinute.new( **kwargs )  
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 895)
+  def _reduce_174(val, _values, result)
+                                 @tree << GoalLineAlt.new( goals: val[1] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 899)
+  def _reduce_175(val, _values, result)
      result = val
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 613)
-  def _reduce_155(val, _values, result)
-     result.push( val[1])
+module_eval(<<'.,.,', 'parser.y', 902)
+  def _reduce_176(val, _values, result)
+     result.push( val[2])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 908)
+  def _reduce_177(val, _values, result)
+                               result = GoalAlt.new( score:   val[0][1][:score],
+                                                 player:  val[1] )
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 614)
-  def _reduce_156(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 913)
+  def _reduce_178(val, _values, result)
+                               goal_minute = GoalMinute.new( **val[2][1] )
+
+                           result = GoalAlt.new( score:     val[0][1][:score],
+                                                 player:    val[1],
+                                                 minute:    goal_minute.to_minute,
+                                                 goal_type: goal_minute.to_goal_type )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 922)
+  def _reduce_179(val, _values, result)
+                               result = GoalAlt.new( score:     val[0][1][:score],
+                                                 player:    val[1],
+                                                 goal_type: GoalType.new( **val[2][1] ))
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 932)
+  def _reduce_180(val, _values, result)
+                               result = GoalAlt.new( player:  val[0],
+                                                 score:   val[1][1][:score] )                         
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 937)
+  def _reduce_181(val, _values, result)
+                               goal_minute = GoalMinute.new( **val[1][1] )
+ 
+                           result = GoalAlt.new( player:    val[0],
+                                                 minute:    goal_minute.to_minute,
+                                                 goal_type: goal_minute.to_goal_type,
+                                                 score:     val[2][1][:score] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 946)
+  def _reduce_182(val, _values, result)
+                               result = GoalAlt.new( player:    val[0],
+                                                 goal_type: GoalType.new( **val[1][1] ),
+                                                 score:     val[2][1][:score] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 958)
+  def _reduce_183(val, _values, result)
+                                 @tree << GoalLineCompat.new( goals: val[1] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 962)
+  def _reduce_184(val, _values, result)
+     result = val
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 964)
+  def _reduce_185(val, _values, result)
      result.push( val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 620)
-  def _reduce_157(val, _values, result)
-                            kwargs = {}.merge( val[0][1] )
-                        result = Minute.new( **kwargs )
+module_eval(<<'.,.,', 'parser.y', 983)
+  def _reduce_186(val, _values, result)
+                               result = GoalCompat.new( minute:  Minute.new(**val[0][1]),
+                                                    player:  val[1],
+                                                    score:  val[2][1][:score] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 989)
+  def _reduce_187(val, _values, result)
+                               result = GoalCompat.new( minute: Minute.new(**val[0][1]),
+                                                    player: val[1],
+                                                    goal_type: GoalType.new( **val[2][1] ),
+                                                    score:  val[3][1][:score] )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 625)
-  def _reduce_158(val, _values, result)
-                            kwargs = { }.merge( val[0][1] ).merge( val[1] )
-                        result = Minute.new( **kwargs )
+module_eval(<<'.,.,', 'parser.y', 996)
+  def _reduce_188(val, _values, result)
+                               result = GoalCompat.new( minute:  Minute.new(**val[0][1]),
+                                                    score:  val[1][1][:score],
+                                                    player:  val[2] )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 629)
-  def _reduce_159(val, _values, result)
-      result = { og: true }
+module_eval(<<'.,.,', 'parser.y', 1002)
+  def _reduce_189(val, _values, result)
+                               result = GoalCompat.new( minute: Minute.new(**val[0][1]),
+                                                    score:  val[1][1][:score],
+                                                    player: val[2],
+                                                    goal_type: GoalType.new( **val[3][1] ))
+
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 630)
-  def _reduce_160(val, _values, result)
-      result = { pen: true }
+module_eval(<<'.,.,', 'parser.y', 1015)
+  def _reduce_190(val, _values, result)
+                                     @tree << AttendanceLine.new( att: val[1][1][:value] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1021)
+  def _reduce_191(val, _values, result)
+                                   @tree << RefereeLine.new( referees: val[1] ) 
+
+    result
+  end
+.,.,
+
+# reduce 192 omitted
+
+module_eval(<<'.,.,', 'parser.y', 1027)
+  def _reduce_193(val, _values, result)
+                                     @tree << AttendanceLine.new( att: val[2][1][:value] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1031)
+  def _reduce_194(val, _values, result)
+     result = [val[0]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1033)
+  def _reduce_195(val, _values, result)
+      result = (val[0] << val[2])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1036)
+  def _reduce_196(val, _values, result)
+      result = Referee.new( name: val[0] )
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1038)
+  def _reduce_197(val, _values, result)
+      result = Referee.new( name: val[0], country: val[1] )
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1043)
+  def _reduce_198(val, _values, result)
+                                   @tree << PenaltiesLine.new( penalties: val[1] )                                                            
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1046)
+  def _reduce_199(val, _values, result)
+      result = [val[0]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1047)
+  def _reduce_200(val, _values, result)
+      result << val[2]
+    result
+  end
+.,.,
+
+# reduce 201 omitted
+
+# reduce 202 omitted
+
+# reduce 203 omitted
+
+# reduce 204 omitted
+
+module_eval(<<'.,.,', 'parser.y', 1057)
+  def _reduce_205(val, _values, result)
+                                     result = Penalty.new( score: val[0][1][:score],
+                                                       name: val[1] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1062)
+  def _reduce_206(val, _values, result)
+                                     result = Penalty.new( score: val[0][1][:score],
+                                                       name: val[1],
+                                                       note: val[2] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1068)
+  def _reduce_207(val, _values, result)
+                                     result = Penalty.new( name: val[0] )                                
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1072)
+  def _reduce_208(val, _values, result)
+                                     result = Penalty.new( name: val[0],
+                                                       note: val[1] )                                
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1079)
+  def _reduce_209(val, _values, result)
+                                   @tree << CardsLine.new( type: 'Y', bookings: val[1] )                               
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1083)
+  def _reduce_210(val, _values, result)
+                                   @tree << CardsLine.new( type: 'R', bookings: val[1] )                    
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1090)
+  def _reduce_211(val, _values, result)
+       result = [val[0]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1092)
+  def _reduce_212(val, _values, result)
+      result << val[2]
+    result
+  end
+.,.,
+
+# reduce 213 omitted
+
+# reduce 214 omitted
+
+# reduce 215 omitted
+
+module_eval(<<'.,.,', 'parser.y', 1099)
+  def _reduce_216(val, _values, result)
+     result = Booking.new( name: val[0] )
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1101)
+  def _reduce_217(val, _values, result)
+     result = Booking.new( name: val[0], minute: val[1][1] )
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1109)
+  def _reduce_218(val, _values, result)
+                              kwargs = { team:    val[0],
+                                     lineup:  val[1]  }.merge( val[2] ) 
+                          @tree << LineupLine.new( **kwargs ) 
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1115)
+  def _reduce_219(val, _values, result)
+     result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1117)
+  def _reduce_220(val, _values, result)
+      result = { coach: val[2] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1119)
+  def _reduce_221(val, _values, result)
+      result = { coach: val[3] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1122)
+  def _reduce_222(val, _values, result)
+     result = [[val[0]]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1125)
+  def _reduce_223(val, _values, result)
+                           ## if lineup_sep is -  start a new sub array!!
+                       if val[1] == '-'
+                          result << [val[2]]
+                       else
+                          result[-1] << val[2]
+                       end
+
+    result
+  end
+.,.,
+
+# reduce 224 omitted
+
+module_eval(<<'.,.,', 'parser.y', 1135)
+  def _reduce_225(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+# reduce 226 omitted
+
+module_eval(<<'.,.,', 'parser.y', 1137)
+  def _reduce_227(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1141)
+  def _reduce_228(val, _values, result)
+     result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1142)
+  def _reduce_229(val, _values, result)
+     result = { cards: val[0] }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1144)
+  def _reduce_230(val, _values, result)
+     result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1145)
+  def _reduce_231(val, _values, result)
+     result = { captain: true }
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1149)
+  def _reduce_232(val, _values, result)
+                                            result = { name: val[0] }.merge( val[1]).merge( val[2] )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1154)
+  def _reduce_233(val, _values, result)
+                                  kwargs = {}.merge(val[0] ).merge( val[1])
+                              result = Lineup.new( **kwargs )
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1174)
+  def _reduce_234(val, _values, result)
+     result = {}
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1177)
+  def _reduce_235(val, _values, result)
+                                  kwargs = {}.merge( val[1] ).merge( val[3] )
+                              sub    = Sub.new( sub:    Lineup.new( **kwargs ),
+                                                minute: Minute.new(val[2][1]) 
+                                              )
+                              result = { sub: sub }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1185)
+  def _reduce_236(val, _values, result)
+                                  sub = Sub.new( sub: val[1] )
+                              result = { sub: sub }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1192)
+  def _reduce_237(val, _values, result)
+                                  sub = Sub.new( sub:    val[2],
+                                             minute: Minute.new(val[1][1]) 
+                                            )
+                              result = { sub: sub }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1201)
+  def _reduce_238(val, _values, result)
+     result = [{ card: 'YELLOW' }.merge( val[0][1] )]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1203)
+  def _reduce_239(val, _values, result)
+     result = [{ card: 'YELLOW' }.merge( val[0][1] ),
+                                 { card: 'YELLOW_RED' }.merge( val[1][1])]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1206)
+  def _reduce_240(val, _values, result)
+     result = [{ card: 'YELLOW' }.merge( val[0][1] ),
+                                { card: 'RED' }.merge( val[1][1])]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1209)
+  def _reduce_241(val, _values, result)
+      result = [{ card: 'RED' }.merge( val[0][1])]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 1211)
+  def _reduce_242(val, _values, result)
+      result = [{ card: 'YELLOW_RED' }.merge( val[0][1])]
     result
   end
 .,.,