{ 61: } 717,
{ 62: } 734,
{ 63: } 751,
{ 64: } 751,
{ 65: } 765,
{ 66: } 779,
{ 67: } 793,
{ 68: } 807,
{ 69: } 821,
{ 70: } 835,
{ 71: } 835,
{ 72: } 835,
{ 73: } 837,
{ 74: } 849,
{ 75: } 852,
{ 76: } 863,
{ 77: } 874,
{ 78: } 885,
{ 79: } 896,
{ 80: } 907,
{ 81: } 918,
{ 82: } 929,
{ 83: } 940,
{ 84: } 951,
{ 85: } 962,
{ 86: } 973,
{ 87: } 984,
{ 88: } 995,
{ 89: } 1015,
{ 90: } 1015,
{ 91: } 1037,
{ 92: } 1037,
{ 93: } 1037,
{ 94: } 1037,
{ 95: } 1037,
{ 96: } 1037,
{ 97: } 1037,
{ 98: } 1037,
{ 99: } 1037,
{ 100: } 1037,
{ 101: } 1037,
{ 102: } 1037,
{ 103: } 1037,
{ 104: } 1037,
{ 105: } 1037
);

yyah : array [0..yynstates-1] of Integer = (
{ 0: } 20,
{ 1: } 23,
{ 2: } 34,
{ 3: } 35,
{ 4: } 55,
{ 5: } 75,
{ 6: } 76,
{ 7: } 76,
{ 8: } 76,
{ 9: } 96,
{ 10: } 97,
{ 11: } 98,
{ 12: } 99,
{ 13: } 100,
{ 14: } 101,
{ 15: } 102,
{ 16: } 103,
{ 17: } 104,
{ 18: } 105,
{ 19: } 106,
{ 20: } 107,
{ 21: } 107,
{ 22: } 108,
{ 23: } 109,
{ 24: } 129,
{ 25: } 149,
{ 26: } 169,
{ 27: } 189,
{ 28: } 209,
{ 29: } 229,
{ 30: } 249,
{ 31: } 249,
{ 32: } 269,
{ 33: } 289,
{ 34: } 309,
{ 35: } 329,
{ 36: } 349,
{ 37: } 369,
{ 38: } 373,
{ 39: } 384,
{ 40: } 401,
{ 41: } 423,
{ 42: } 427,
{ 43: } 437,
{ 44: } 457,
{ 45: } 477,
{ 46: } 497,
{ 47: } 517,
{ 48: } 537,
{ 49: } 557,
{ 50: } 577,
{ 51: } 597,
{ 52: } 617,
{ 53: } 637,
{ 54: } 657,
{ 55: } 677,
{ 56: } 697,
{ 57: } 708,
{ 58: } 712,
{ 59: } 716,
{ 60: } 716,
{ 61: } 733,
{ 62: } 750,
{ 63: } 750,
{ 64: } 764,
{ 65: } 778,
{ 66: } 792,
{ 67: } 806,
{ 68: } 820,
{ 69: } 834,
{ 70: } 834,
{ 71: } 834,
{ 72: } 836,
{ 73: } 848,
{ 74: } 851,
{ 75: } 862,
{ 76: } 873,
{ 77: } 884,
{ 78: } 895,
{ 79: } 906,
{ 80: } 917,
{ 81: } 928,
{ 82: } 939,
{ 83: } 950,
{ 84: } 961,
{ 85: } 972,
{ 86: } 983,
{ 87: } 994,
{ 88: } 1014,
{ 89: } 1014,
{ 90: } 1036,
{ 91: } 1036,
{ 92: } 1036,
{ 93: } 1036,
{ 94: } 1036,
{ 95: } 1036,
{ 96: } 1036,
{ 97: } 1036,
{ 98: } 1036,
{ 99: } 1036,
{ 100: } 1036,
{ 101: } 1036,
{ 102: } 1036,
{ 103: } 1036,
{ 104: } 1036,
{ 105: } 1038
);

yygl : array [0..yynstates-1] of Integer = (
{ 0: } 1,
{ 1: } 4,
{ 2: } 4,
{ 3: } 4,
{ 4: } 4,
{ 5: } 6,
{ 6: } 8,
{ 7: } 8,
{ 8: } 8,
{ 9: } 8,
{ 10: } 10,
{ 11: } 10,
{ 12: } 10,
{ 13: } 10,
{ 14: } 10,
{ 15: } 10,
{ 16: } 10,
{ 17: } 10,
{ 18: } 10,
{ 19: } 10,
{ 20: } 10,
{ 21: } 10,
{ 22: } 10,
{ 23: } 10,
{ 24: } 10,
{ 25: } 12,
{ 26: } 14,
{ 27: } 16,
{ 28: } 18,
{ 29: } 20,
{ 30: } 22,
{ 31: } 24,
{ 32: } 24,
{ 33: } 26,
{ 34: } 28,
{ 35: } 30,
{ 36: } 32,
{ 37: } 34,
{ 38: } 36,
{ 39: } 36,
{ 40: } 36,
{ 41: } 36,
{ 42: } 39,
{ 43: } 39,
{ 44: } 39,
{ 45: } 41,
{ 46: } 43,
{ 47: } 45,
{ 48: } 47,
{ 49: } 49,
{ 50: } 51,
{ 51: } 53,
{ 52: } 55,
{ 53: } 57,
{ 54: } 59,
{ 55: } 61,
{ 56: } 63,
{ 57: } 65,
{ 58: } 65,
{ 59: } 65,
{ 60: } 65,
{ 61: } 65,
{ 62: } 65,
{ 63: } 65,
{ 64: } 65,
{ 65: } 65,
{ 66: } 65,
{ 67: } 65,
{ 68: } 65,
{ 69: } 65,
{ 70: } 65,
{ 71: } 65,
{ 72: } 65,
{ 73: } 65,
{ 74: } 65,
{ 75: } 65,
{ 76: } 65,
{ 77: } 65,
{ 78: } 65,
{ 79: } 65,
{ 80: } 65,
{ 81: } 65,
{ 82: } 65,
{ 83: } 65,
{ 84: } 65,
{ 85: } 65,
{ 86: } 65,
{ 87: } 65,
{ 88: } 65,
{ 89: } 67,
{ 90: } 67,
{ 91: } 70,
{ 92: } 70,
{ 93: } 70,
{ 94: } 70,
{ 95: } 70,
{ 96: } 70,
{ 97: } 70,
{ 98: } 70,
{ 99: } 70,
{ 100: } 70,
{ 101: } 70,
{ 102: } 70,
{ 103: } 70,
{ 104: } 70,
{ 105: } 70
);

yygh : array [0..yynstates-1] of Integer = (
{ 0: } 3,
{ 1: } 3,
{ 2: } 3,
{ 3: } 3,
{ 4: } 5,
{ 5: } 7,
{ 6: } 7,
{ 7: } 7,
{ 8: } 7,
{ 9: } 9,
{ 10: } 9,
{ 11: } 9,
{ 12: } 9,
{ 13: } 9,
{ 14: } 9,
{ 15: } 9,
{ 16: } 9,
{ 17: } 9,
{ 18: } 9,
{ 19: } 9,
{ 20: } 9,
{ 21: } 9,
{ 22: } 9,
{ 23: } 9,
{ 24: } 11,
{ 25: } 13,
{ 26: } 15,
{ 27: } 17,
{ 28: } 19,
{ 29: } 21,
{ 30: } 23,
{ 31: } 23,
{ 32: } 25,
{ 33: } 27,
{ 34: } 29,
{ 35: } 31,
{ 36: } 33,
{ 37: } 35,
{ 38: } 35,
{ 39: } 35,
{ 40: } 35,
{ 41: } 38,
{ 42: } 38,
{ 43: } 38,
{ 44: } 40,
{ 45: } 42,
{ 46: } 44,
{ 47: } 46,
{ 48: } 48,
{ 49: } 50,
{ 50: } 52,
{ 51: } 54,
{ 52: } 56,
{ 53: } 58,
{ 54: } 60,
{ 55: } 62,
{ 56: } 64,
{ 57: } 64,
{ 58: } 64,
{ 59: } 64,
{ 60: } 64,
{ 61: } 64,
{ 62: } 64,
{ 63: } 64,
{ 64: } 64,
{ 65: } 64,
{ 66: } 64,
{ 67: } 64,
{ 68: } 64,
{ 69: } 64,
{ 70: } 64,
{ 71: } 64,
{ 72: } 64,
{ 73: } 64,
{ 74: } 64,
{ 75: } 64,
{ 76: } 64,
{ 77: } 64,
{ 78: } 64,
{ 79: } 64,
{ 80: } 64,
{ 81: } 64,
{ 82: } 64,
{ 83: } 64,
{ 84: } 64,
{ 85: } 64,
{ 86: } 64,
{ 87: } 64,
{ 88: } 66,
{ 89: } 66,
{ 90: } 69,
{ 91: } 69,
{ 92: } 69,
{ 93: } 69,
{ 94: } 69,
{ 95: } 69,
{ 96: } 69,
{ 97: } 69,
{ 98: } 69,
{ 99: } 69,
{ 100: } 69,
{ 101: } 69,
{ 102: } 69,
{ 103: } 69,
{ 104: } 69,
{ 105: } 69
);

yyr : array [1..yynrules] of YYRRec = (
{ 1: } ( len: 2; sym: -2 ),
{ 2: } ( len: 3; sym: -3 ),
{ 3: } ( len: 3; sym: -3 ),
{ 4: } ( len: 3; sym: -3 ),
{ 5: } ( len: 3; sym: -3 ),
{ 6: } ( len: 3; sym: -3 ),
{ 7: } ( len: 2; sym: -3 ),
{ 8: } ( len: 4; sym: -3 ),
{ 9: } ( len: 4; sym: -3 ),
{ 10: } ( len: 4; sym: -3 ),
{ 11: } ( len: 4; sym: -3 ),
{ 12: } ( len: 4; sym: -3 ),
{ 13: } ( len: 4; sym: -3 ),
{ 14: } ( len: 4; sym: -3 ),
{ 15: } ( len: 4; sym: -3 ),
{ 16: } ( len: 4; sym: -3 ),
{ 17: } ( len: 4; sym: -3 ),
{ 18: } ( len: 4; sym: -3 ),
{ 19: } ( len: 4; sym: -3 ),
{ 20: } ( len: 4; sym: -3 ),
{ 21: } ( len: 4; sym: -3 ),
{ 22: } ( len: 5; sym: -3 ),
{ 23: } ( len: 1; sym: -3 ),
{ 24: } ( len: 1; sym: -3 ),
{ 25: } ( len: 1; sym: -3 ),
{ 26: } ( len: 0; sym: -4 ),
{ 27: } ( len: 3; sym: -4 ),
{ 28: } ( len: 1; sym: -4 ),
{ 29: } ( len: 1; sym: -4 ),
{ 30: } ( len: 3; sym: -5 ),
{ 31: } ( len: 3; sym: -5 ),
{ 32: } ( len: 2; sym: -5 ),
{ 33: } ( len: 3; sym: -5 ),
{ 34: } ( len: 3; sym: -5 ),
{ 35: } ( len: 3; sym: -5 ),
{ 36: } ( len: 3; sym: -5 ),
{ 37: } ( len: 3; sym: -5 ),
{ 38: } ( len: 3; sym: -5 ),
{ 39: } ( len: 3; sym: -5 )
);


const _error = 256; (* error token *)

function yyact(state, sym : Integer; var act : Integer) : Boolean;
  (* search action table *)
  var k : Integer;
  begin
    k := yyal[state];
    while (k<=yyah[state]) and (yya[k].sym<>sym) do inc(k);
    if k>yyah[state] then
      yyact := false
    else
      begin
        act := yya[k].act;
        yyact := true;
      end;
  end(*yyact*);

function yygoto(state, sym : Integer; var nstate : Integer) : Boolean;
  (* search goto table *)
  var k : Integer;
  begin
    k := yygl[state];
    while (k<=yygh[state]) and (yyg[k].sym<>sym) do inc(k);
    if k>yygh[state] then
      yygoto := false
    else
      begin
        nstate := yyg[k].act;
        yygoto := true;
      end;
  end(*yygoto*);

label parse, next, error, errlab, shift, reduce, accept, abort;

begin(*yyparse*)
  (* initialize: *)

  yystate := 0; ylib.yychar := -1; ylib.yynerrs := 0; ylib.yyerrflag := 0; yysp := 0;

{$ifdef ylib.yydebug}
  ylib.yydebug := true;
{$else}
  ylib.yydebug := false;
{$endif}

parse:

  (* push state and value: *)

  inc(yysp);
  if yysp>yymaxdepth then
    begin
      ylib.yyerror('yyparse stack overflow');
      goto abort;
    end;
  yys[yysp] := yystate; yyv[yysp] := yyval;

next:

  if (yyd[yystate]=0) and (ylib.yychar=-1) then
    (* get next symbol *)
    begin
      ylib.yychar := ylex.yylex(yylval); if ylib.yychar<0 then ylib.yychar := 0;
      //ShowMessage(ylex.llib.yytext);
      //Writeln(ylex.llib.yyoutput,ylex.llib.yytext); { Gp !!! }
    end;

  if ylib.yydebug then writeln('state ', yystate, ', char ', ylib.yychar);

  (* determine parse action: *)

  yyn := yyd[yystate];
  if yyn<>0 then goto reduce; (* simple state *)

  (* no default action; search parse table *)

  if not yyact(yystate, ylib.yychar, yyn) then goto error
  else if yyn>0 then                      goto shift
  else if yyn<0 then                      goto reduce
  else                                    goto accept;

error:

  (* error; start error recovery: *)

  if ylib.yyerrflag=0 then ylib.yyerror('syntax error');

errlab:

  if ylib.yyerrflag=0 then inc(ylib.yynerrs);     (* new error *)

  if ylib.yyerrflag<=2 then                  (* incomplete recovery; try again *)
    begin
      ylib.yyerrflag := 3;
      (* uncover a state with shift action on error token *)
      while (yysp>0) and not ( yyact(yys[yysp], _error, yyn) and
                               (yyn>0) ) do
        begin
          if ylib.yydebug then
            if yysp>1 then
              writeln('error recovery pops state ', yys[yysp], ', uncovers ',
                      yys[yysp-1])
            else
              writeln('error recovery fails ... abort');
          dec(yysp);
        end;
      if yysp=0 then goto abort; (* parser has fallen from stack; abort *)
      yystate := yyn;            (* simulate shift on error *)
      goto parse;
    end
  else                                  (* no shift yet; discard symbol *)
    begin
      if ylib.yydebug then writeln('error recovery discards char ', ylib.yychar);
      if ylib.yychar=0 then goto abort; (* end of input; abort *)
      ylib.yychar := -1; goto next;     (* clear lookahead char and try again *)
    end;

shift:

  (* go to new state, clear lookahead character: *)

  yystate := yyn; ylib.yychar := -1; yyval := yylval;
  if ylib.yyerrflag>0 then dec(ylib.yyerrflag);

  goto parse;

reduce:

  (* execute action, pop rule from stack, and go to next state: *)

  if ylib.yydebug then writeln('reduce ', -yyn);

  ylib.yyflag := yyfnone; yyaction(-yyn);
  dec(yysp, yyr[-yyn].len);
  if yygoto(yys[yysp], yyr[-yyn].sym, yyn) then yystate := yyn;

  (* handle action calls to yyaccept, yyabort and ylib.yyerror: *)

  case ylib.yyflag of
    yyfaccept : goto accept;
    yyfabort  : goto abort;
    yyferror  : goto errlab;
  end;

  goto parse;

accept:

  yyparse := 0; exit;

abort:

  yyparse := 1; exit;
end(*yyparse*);



{$I exprlex}