program BackEnd(input,output);
 const
     tkasg=257; tkne=258; tkle=259; tkge=270; tkdtdt=271;
     tkabsolute=272; tkand=273; tkarray=273; tkbegin=274;
     tkcase=275; tkconst=276; tkdiv=277; tkdo=278; tkdownto=279;
     tkelse=280; tkend=281; tkexternal=282; tkfile=283;
     tkforward=284; tkfor=285; tkfunction=286; tkgoto=287;
     tkinline=288; tkif=289; tkin=290; tklabel=291; tkmod=292;
     tknil=293; tknot=294; tkoverlay=295; tkof=296; tkpacked=297;
     tkprocedure=298; tkprogram=299; tkrecord=300;
     tkrepeat=301; tkset=302; tkshl=303; tkshr=304; tkstring=305;
     tkthen=306; tktype=307; tkto=308; tkuntil=309;
     tkvar=310; tkwhile=311; tkwith=312; tkxor=313; tktext=314;
     tkchar=315; tkreadln=316; tkwriteln=317; tkreal=318; tkboolean=319;
     tkinteger=320; tkread=321; tkwrite=322; tktrue=323; tkfalse=324;
     lex_string=325; lex_real=326; lex_ident=327; lex_integer=328;
     subtree=1;
     literal=2;
     ident=3;
     token=4;
     integer_ident=5;
     real_ident=6;
     string_ident=7;
     empty=8;


 type
     treeSize = 1..1300;
     symtableSize = 1..500;

     treeNodeType = record
                    rhsn :integer;
                    rhstype : array[1..10] of integer;
                    rhsindex : array[1..10] of integer
                    end;

     ParseTreeType = array[treeSize] of treeNodeType;

 var
     debug : boolean;
     symf,intf,realf,stringf,treef : text;
     symtable : array [symtableSize] of pointer;
     inttable : array [symtableSize] of pointer;
     realtable : array [symtableSize] of pointer;
     stringtable : array [symtableSize] of pointer;
     tree : parseTreeType;
     string_last : integer;
     symtable_last : integer;
     inttable_last : integer;
     realtable_last : integer;
     tree_last : integer;
  (*****************************************)
  procedure readSymTable;
    var
    data : string[80];
    debug_buf : string[80];
    begin
      assign(symf,'a:symff.dat'); reset(symf);
      readln(symf,data);

      while not eof(symf) do
         begin
                      if debug then writeln('symtable_last='
                                          ,symtable_last);
                      symtable_last := symtable_last +1;
                      getmem(symtable[symtable_last] (*place address here*)
                            ,sizeof(data)             (* for this many bytes *)
                            );

                      if debug then writeln('dat read=',data);
                      if debug then writeln('len=',length(data));

                      move(data                        (* source *)
                          ,symtable[symtable_last]^     (* dest   *)
                          ,sizeof(data)                (* how many bytes *)
                          );
                 if (debug) then begin
                 move(symtable[symtable_last]^    (* source *)
                     ,debug_buf                   (* dest   *)
                     ,sizeof(data)                (* how many bytes *)
                     );
                 writeln('**debug buf=',debug_buf);
                 end;
          readln(symf,data);
          end; (* while *)

      close(symf);
  end;
 (********************************************)
  procedure readStringTable;
  var
   len : integer;       (* length of data to follow *)
    data : string[77];    (* 80 bytes - 2 bytes len - 1 byte blank
                           i assumed that max identifire len is 77
                           but i can change this easily *)
    blank : char;        (* separate len and data *)
    begin
     if debug then writeln('in readstringtable');
     assign(stringf,'a:stringf.dat'); reset(stringf);

      readln(stringf,len,blank,data);
      while not eof(stringf) do
         begin
                      if debug then writeln('string_last=',string_last);
                      string_last := string_last +1;
                      getmem(stringtable[string_last]  (* place address here *)
                            ,len                   (* for this many bytes *)
                            );

                      move(data                    (* source *)
                          ,stringtable[string_last]^  (* dest   *)
                          ,len                     (* how many bytes *)
                          );
                     if debug then
                         writeln('stringtable[',string_last,']='
                                 ,data,'size=',
                                 len);
          readln(stringf,len,blank,data);
          end; (* while *)


     close(stringf);
    end;
(**********************************************)
 procedure readintTable;
   var
    len : integer;       (* length of data to follow *)
    data : string[77];    (* 80 bytes - 2 bytes len - 1 byte blank
                           i assumed that max identifire len is 77
                           but i can change this easily *)
    blank : char;        (* separate len and data *)
   begin
      if debug then writeln('in readinttable');
      assign(intf,'a:intf.dat'); reset(intf);

      readln(intf,len,blank,data);
      while not eof(intf) do
         begin
                      if debug then writeln('inttable_last='
                                  ,inttable_last);
                      inttable_last := inttable_last+1;
                      getmem(symtable[inttable_last] (* place address here *)
                            ,len    (* for this many bytes *)
                            );

                      move(data             (* source *)
                          ,symtable[inttable_last]^  (* dest   *)
                          ,len                       (* how many bytes *)
                          );
                     if debug then
                         writeln('symtable[',inttable_last,']='
                                 ,data,'size=',
                                 len);
          readln(intf,len,blank,data);
          end; (* while *)

       close(intf);
    end;
 (********************************************)
 procedure readrealTable;
  var
   len : integer;       (* length of data to follow *)
    data : string[77];    (* 80 bytes - 2 bytes len - 1 byte blank
                           i assumed that max identifire len is 77
                           but i can change this easily *)
    blank : char;        (* separate len and data *)
  begin
   if debug then writeln(' in readrealtable');
   assign(realf,'a:realf.dat'); reset(realf);

      readln(realf,len,blank,data);
      while not eof(realf) do
         begin
                      if debug then writeln('realtable_last='
                                            ,realtable_last);
                      realtable_last := realtable_last +1;
                      getmem(symtable[realtable_last] (* place address here *)
                            ,len                    (* for this many bytes *)
                            );

                      move(data                       (* source *)
                          ,symtable[realtable_last]^  (* dest   *)
                          ,len                        (* how many bytes *)
                          );
                     if debug then
                         writeln('symtable[',realtable_last,']=',
                                 data,'size=',
                                 len);
          readln(realf,len,blank,data);
          end; (* while *)

   close(realf);

  end;
 (*********************************************)
  procedure readParseTree;
   var
     j: integer;
     blank :char;

   begin
    exit;
    if debug then writeln('in read parse tree');
    assign(treef,'a:treef.dat'); reset(treef);

    read(treef,tree[tree_last].rhsn);
    while not eof(treef) do
          begin
               while not eoln(treef) do
                     begin
                          tree_last := tree_last + 1;
                          for j:= 1 to tree[tree_last].rhsn do
                              read(treef
                                  ,blank
                                  ,tree[tree_last].rhstype[j]
                                  );
                           for j:=1 to tree[tree_last].rhsn do
                              read(treef
                                   ,blank
                                   ,tree[tree_last].rhsindex[j]
                                   )
                     end;
                     readln(treef);
          read(treef,tree[tree_last].rhsn);
          end; (* while not eof *)

    close(treef);
   end;
  (********************************************)
  procedure dumpall;
    begin
     end;
 (*************************************************)
 procedure init;
   begin
      string_last :=0;
      symtable_last :=0;
      inttable_last :=0;
      realtable_last :=0;
      tree_last := 0
   end;
   (************************************************)
 procedure receive_parsor_output;
  begin
     readSymTable;
  readIntTable;
  readRealTable;
  readStringTable;
  readParseTree;
  if debug then dumpAll
  else

 end;
 (**********************************************************)

begin
  debug := true;
  init;
  receive_parsor_output;



end.