comEngine_HRE_distribute.c

Go to the documentation of this file.

/*
 
  $Id: comEngine_HRE_distribute.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.
 
  See the GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/*
This file contains the functions to generate the HRE code using several
processes on the HRE
 */
 
#include <stdio.h>
#include <ctype.h>
 
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
 
#include "resources.h"
 
#include "misc.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
 
#include "text-util.h"
 
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "polyedre.h"
 
#include "phrase_tools.h"
 
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
 
#include "phrase_distribution.h"
#include "comEngine.h"
#include "comEngine_generate_code.h"
#include "phrase.h"
 
// gOldIndToNewInd associated a loop index of
// input code to a loop index of the new one
static hash_table gOldIndToNewInd;
 
// gIsIndex is used to store the fact that 
// an index has to be incremented
static hash_table gIsIndex;
 
static list gCurStats = NIL;
static list glCurRep = NIL;
 
// These are global variable to the names we want to
// give to the created modules
static const char* g_new_module_name = NULL;
static const char* g_module_name = NULL;
 
// This variable holds the number of
// if we have entered at a given point of
// the algorithm
static int gIfCount = 0;
 
// This list holds the enclosing loops at a given point of 
// the algorithm
static list glCurLoop = NIL;
 
static entity gNewInd = entity_undefined;
 
// These lists hold the read or write statements that 
// make to read values from the fifos
static list glReadStats = NIL;
static list glWriteStats = NIL;
 
static statement HRE_distribute_stat(statement stat, bool calledFromLoop);
 
/*
This function creates the private variables of the new module. Then,
it store the association between the created variable and the old reference
holded by lRef ingRefToHREVar
 */
static void generate_scalar_variables_from_list(list lRef)
{
  MAP(REFERENCE, curRef,
  {
    bool alreadyDone = false;
    reference refFound = reference_undefined;
 
    HASH_MAP(ref1, var1,
    {
      if(reference_equal_p(curRef, ref1))
        {
          alreadyDone = true;
          refFound = ref1;
          break;
        }
    }, gRefToHREVar);
 
    if(!alreadyDone)
      {
        //printf("it\n");
        //print_reference(curRef);printf("\n");
 
        string name =
          strdup(entity_local_name(reference_variable((reference)curRef)));
 
        basic bas = basic_of_reference((reference)curRef);
 
        pips_assert("bas != basic_undefined", bas != basic_undefined);
 
        //entity new_ent = make_new_scalar_entity(name, copy_basic(bas));
 
        entity new_ent = make_new_scalar_variable_with_prefix(name,
                                                              get_current_module_entity(),
                                                              bas);
    AddEntityToCurrentModule(new_ent);
 
        //printf("%s\n", entity_user_name(new_ent));
 
        if(hash_get(gRefToHREVar, curRef) == HASH_UNDEFINED_VALUE)
          {
            hash_put(gRefToHREVar, curRef, new_ent);
          }
      }
    else
      {
        //printf("it found\n");
        //print_reference(curRef);printf("\n");
 
        entity scalEnt = hash_get(gRefToHREVar, refFound);
 
        if(hash_get(gRefToHREVar, curRef) == HASH_UNDEFINED_VALUE)
          {
            hash_put(gRefToHREVar, curRef, scalEnt);
          }
      }
 
  }, lRef);
 
}
 
/*
This function creates a private entity whose prefix is the local name
of ind
 */
static entity find_or_create_newInd(entity ind, bool bIsInd)
{
  entity new_ent = entity_undefined;
 
  // If the entity was already created, then just return the existing
  // entity
  new_ent = hash_get(gOldIndToNewInd, ind);
 
  if(new_ent != HASH_UNDEFINED_VALUE)
    {
      return new_ent;
    }
 
  // Create a new entity
  new_ent =
    make_new_scalar_variable_with_prefix(entity_local_name(ind),
                                         get_current_module_entity(),
                                         copy_basic(entity_basic(ind)));
  AddEntityToCurrentModule(new_ent);
 
  statement loopStat = STATEMENT(CAR(glCurLoop));
 
  list lUnSupportedRef = hash_get(gLoopToUnSupRef, loopStat);
 
  pips_assert("lUnSupportedRef != HASH_UNDEFINED_VALUE",
              lUnSupportedRef != HASH_UNDEFINED_VALUE);
 
  // If the entity created is actually the index of 
  // the new loop, then do gNewInd = new_ent
  if((loop_index(statement_loop(loopStat)) == ind) &&
     (lUnSupportedRef == NIL))
    {
      gNewInd = new_ent;
    }
 
  // Memorize the creation of the entity
  hash_put(gOldIndToNewInd, ind, new_ent);
 
  // If the entity is an index, then memorize it with gIsIndex
  if(bIsInd)
    {
      hash_put(gIsIndex, new_ent, (void *)true);
    }
 
  return new_ent;
}
 
/*
Get the expression that defines the index of the fifo that has to be
read or written
 */
static expression get_indExp_from_ref(reference curRef, hash_table ht,
                                      bool * innerInd)
{
  entity ind = entity_undefined;
 
  HASH_MAP(ref1, ind1,
  {
    if(reference_equal_p(curRef, ref1))
      {
        ind = ind1;
        break;
      }
  }, ht);
 
  expression indExp;
 
  // If the index ind is undefined then let read from the 
  // beginning of the fifo
  if(ind == entity_undefined)
    {
      indExp = int_to_expression(0);
    }
  else
    {
      if(loop_index(statement_loop(STATEMENT(CAR(glCurLoop)))) == ind)
        {
          *innerInd = true;
        }
 
      entity new_ent = find_or_create_newInd(ind, true);
 
      indExp = entity_to_expression(new_ent);
    }
 
  return indExp;
}
 
/*
Get the expression that defines the fifo that has to be
read or written
 */
expression get_fifoExp_from_ref(reference curRef, expression buffExp,
                                hash_table ht)
{
  entity ind = entity_undefined;
 
  HASH_MAP(ref1, ind1,
  {
    if(reference_equal_p(curRef, ref1))
      {
        ind = ind1;
        break;
      }
  }, ht);
 
  expression fifoExp;
 
  if(ind == entity_undefined)
    {
      fifoExp = buffExp;
    }
  else
    {
      entity new_ent = find_or_create_newInd(ind, false);
 
      list addArg = gen_make_list(expression_domain,
                                  buffExp,
                                  entity_to_expression(new_ent),
                                  NULL);
 
      fifoExp =
        call_to_expression(make_call(entity_intrinsic(PLUS_OPERATOR_NAME),
                                     addArg));
    }
 
  return fifoExp;
}
 
static statement make_read_write_fifo_stat(string name,
                                           expression fifoExp,
                                           expression indExp,
                                           expression hreBuffExp)
{
  statement newStat;
 
  if(!strcmp(name, READ_FIFO))
    {
      list arg = gen_make_list(expression_domain,
                               fifoExp,
                               indExp,
                               NULL);
 
      expression rExp = call_to_expression(make_call(module_name_to_runtime_entity(name), 
                                            arg));
 
      newStat = make_assign_statement(hreBuffExp, rExp);
    }
  else
    {
      list arg = gen_make_list(expression_domain,
                               fifoExp,
                               indExp,
                               hreBuffExp,
                               NULL);
 
      newStat = call_to_statement(
                                  make_call(module_name_to_runtime_entity(name), 
                                            arg));
    }
 
  return newStat;
}
 
/*
This function generates the statement that read or write the value
(corresponding to the old reference curRef) in the fifo
*/
statement generate_fifo_stat2(reference curRef, bool bRead)
{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  expression buffExp = get_fifo_from_ref(curRef);
 
  //printf("generate_fifo_stat2\n");
  //print_reference(curRef);printf("\n");
 
  if(buffExp == expression_undefined)
    {
      return statement_undefined;
    }
 
  bool innerInd = false;
 
  expression indExp = get_indExp_from_ref(curRef, gRefToInd, &innerInd);
 
  expression fifoExp = get_fifoExp_from_ref(curRef, buffExp, gRefToToggle);
 
  entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
  pips_assert("hreBuffEnt != entity_undefined",
              hreBuffEnt != entity_undefined);
 
  if(bRead)
    {
      name = strdup(READ_FIFO);
    }
  else
    {
      name = strdup(WRITE_FIFO);
    }
 
  newStat = make_read_write_fifo_stat(name, fifoExp, indExp,
                                      entity_to_expression(hreBuffEnt));
 
  if(!innerInd)
    {
      if(bRead)
        {
          glReadStats = CONS(STATEMENT, newStat, glReadStats);
        }
      else
        {
          glWriteStats = CONS(STATEMENT, newStat, glWriteStats);
        }
 
      return statement_undefined;
    }
 
  return newStat;
}
 
/*
This function generates the statement that read or write the value
(corresponding to the old entity oldInd) in the fifo
*/
statement generate_ind_fifo_stat2(entity oldInd, entity newInd, bool bRead)
{
  statement newStat = statement_undefined;
 
  string name = NULL;
 
  intptr_t indNum = (intptr_t)hash_get(gIndToNum, oldInd);
 
  pips_assert("indNum != HASH_UNDEFINED_VALUE",
              indNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  if(bRead)
    {
      name = strdup(READ_FIFO);
    }
  else
    {
      name = strdup(WRITE_FIFO);
    }
 
  intptr_t fifoNum = (intptr_t)hash_get(gEntToHREFifo, oldInd);
 
  pips_assert("fifoNum != HASH_UNDEFINED_VALUE",
              fifoNum != (intptr_t)HASH_UNDEFINED_VALUE);
 
  newStat =
    make_read_write_fifo_stat(name,
                              int_to_expression(fifoNum),
                              int_to_expression(indNum),
                              entity_to_expression(newInd));
  return newStat;
}
 
/*
This function generates the read or write statements
 */
void generate_fifo_stats2(list lRef,
                         list * lReadStats, list * lWriteStats)
{
  list lReadDone = NIL;
  list lWriteDone = NIL;
 
  MAP(REFERENCE, curRef,
  {
    string effAction = hash_get(gRefToEff, curRef);
 
    pips_assert("effAction != HASH_UNDEFINED_VALUE",
                effAction != HASH_UNDEFINED_VALUE);
 
    //printf("fifo ref %d\n", (int)curRef);
    //print_reference(curRef);printf("\n");
 
    if(!strcmp(effAction, R_EFFECT))
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lReadDone);
 
        if(!alreadyDone)
          {
            //printf("read eff\n");
 
            lReadDone = gen_nconc(lReadDone, CONS(REFERENCE, curRef, NIL));
 
            statement readStat = generate_fifo_stat2(curRef, true);
 
            if(readStat == statement_undefined)
              {
                continue;
              }
 
            *lReadStats = gen_nconc(*lReadStats, CONS(STATEMENT, readStat, NIL));
            //print_statement(readStat);
          }
      }
    else
      {
        bool alreadyDone = false;
 
        MAP(REFERENCE, doneRef,
        {
          if(reference_equal_p(curRef, doneRef))
            {
              alreadyDone = true;
              break;
            }
        }, lWriteDone);
 
        if(!alreadyDone)
          {
            //printf("write eff\n");
 
            lWriteDone = gen_nconc(lWriteDone, CONS(REFERENCE, curRef, NIL));
 
            statement writeStat = generate_fifo_stat2(curRef, false);
 
            if(writeStat == statement_undefined)
              {
                continue;
              }
 
            *lWriteStats = gen_nconc(*lWriteStats, CONS(STATEMENT, writeStat, NIL));
 
            //print_statement(writeStat);
          }
      }
 
  }, lRef);
 
  gen_free_list(lReadDone);
  gen_free_list(lWriteDone);
}
 
/*
This function replaces the old references with new references
 */
static void replace_array_ref_with_fifos2(list lRef, statement * newStat)
{
  list lStats = NIL;
 
  list lReadStats = NIL;
  list lWriteStats = NIL;
printf("replace_array_ref_with_fifos2\n");
  generate_fifo_stats2(lRef, &lReadStats, &lWriteStats);
printf("replace_array_ref_with_fifos2 1\n");
  FOREACH(REFERENCE, curRef,lRef)
  {
    printf("replace_array_ref %p\n", curRef);
    print_reference(curRef);printf("\n");
 
    entity hreBuffEnt = get_HRE_buff_ent_from_ref(curRef);
 
    pips_assert("hreBuffEnt != entity_undefined",
                hreBuffEnt != entity_undefined);
 
    reference hreBuffRef = make_reference(hreBuffEnt, NIL);
 
    comEngine_replace_reference_in_stat(*newStat, curRef, reference_to_expression(hreBuffRef));
 
  }
 
  lStats = lReadStats;
  if(*newStat != statement_undefined)
    {
      lStats = gen_nconc(lStats, CONS(STATEMENT, *newStat, NIL));
    }
  lStats = gen_nconc(lStats, lWriteStats);
 
  *newStat = make_block_statement(lStats);
}
 
/*
This function adds the read and write statements to the module statements
 */
static statement add_index_statements(statement stat)
{
  list lReadStats = NIL;
  //list lWriteStats = NIL;
 
  HASH_MAP(oldInd, newInd,
  {
    if(newInd == gNewInd)
      {
        continue;
      }
 
    statement readStat = generate_ind_fifo_stat2(oldInd, newInd, true);
 
    lReadStats = CONS(STATEMENT, readStat, lReadStats);
 
    //statement writeStat = generate_ind_fifo_stat2(oldInd, newInd, false);
 
    //lWriteStats = CONS(STATEMENT, writeStat, lWriteStats);
 
  }, gOldIndToNewInd);
 
  list lStats = NIL;
 
  lStats = gen_nconc(lStats, lReadStats);
  lStats = gen_nconc(lStats, glReadStats);
  lStats = gen_nconc(lStats, CONS(STATEMENT, stat, NIL));
  lStats = gen_nconc(lStats, glWriteStats);
  //lStats = gen_nconc(lStats, lWriteStats);
 
  return make_block_statement(lStats);
}
 
/*
This function generate the statement of a new module
 */
static statement generate_code()
{
  if(gCurStats == NIL)
    {
      return make_block_statement(NIL);
    }
 
  printf("generate_code\n");
 
  generate_scalar_variables_from_list(glCurRep);
 
  /*printf("glCurRep\n");
  MAP(REFERENCE, curRef,
  {
    printf("glCurRep it\n");
    print_reference(curRef);printf("\n");
  }, glCurRep);
*/
  statement newStat = make_block_statement(gCurStats);
 
  printf("newStat bef\n");
  print_statement(newStat);
 
  replace_array_ref_with_fifos2(glCurRep, &newStat);
 
  printf("newStat aft 1\n");
  print_statement(newStat);
 
  if(gNewInd != entity_undefined)
    {
      loop curLoop = statement_loop(STATEMENT(CAR(glCurLoop)));
 
      loop newLoop = make_loop(gNewInd,
                               make_range(int_to_expression(0),
                                          copy_expression(gBufferSizeEnt),
                                          int_to_expression(1)),
                               newStat,
                               loop_label(curLoop),
                               make_execution(is_execution_sequential, UU),
                               NIL);
 
      newStat = make_statement(entity_empty_label(),
                               STATEMENT_NUMBER_UNDEFINED,
                               STATEMENT_ORDERING_UNDEFINED,
                               empty_comments,
                               make_instruction_loop(newLoop),NIL,NULL,
                               empty_extensions (), make_synchronization_none());
    }
 
  newStat = add_index_statements(newStat);
 
  // Reinitialize global variables
  glReadStats = NIL;
  glWriteStats = NIL;
 
  gen_free_list(glCurRep);
 
  gCurStats = NIL;
  glCurRep = NIL;
 
  hash_table_free(gOldIndToNewInd);
  gOldIndToNewInd = hash_table_make(hash_pointer, 0);
  gNewInd = entity_undefined;
 
  hash_table_free(gRefToHREVar);
  gRefToHREVar = hash_table_make(hash_pointer, 0);
 
  return newStat;
}
 
/*
this function makes an empty module
 */
static void make_HRE_empty_module()
{
  static int number = 0;
 
  string num  = int2a(number++);
  string prefix = strdup(concatenate(g_new_module_name,"_",
                                     num,
                                     (char *) NULL));
  free(num);
 
  entity new_fun = make_empty_subroutine(prefix,make_language_unknown());
 
  reset_current_module_entity();
 
  set_current_module_entity(new_fun);
}
 
/*
This function assigns statement stat to the current empty module
 */
static void fill_HRE_module(statement stat)
{
  create_HRE_module(entity_local_name(get_current_module_entity()),
                    g_module_name, stat, get_current_module_entity());
}
 
/*
This function generates a new HRE module if (gCurStats != NIL)
 */
static void loop_enter()
{
  if(gCurStats == NIL)
    {
      return;
    }
 
  make_HRE_empty_module();
 
  statement newStat = generate_code();
 
  fill_HRE_module(newStat);
}
 
#if 0
static void create_loop_HRE_module()
{
  if(glCurLoop == NIL)
    {
      return;
    }
 
  make_HRE_empty_module();
 
  list lStats = NIL;
  list lReadStats = NIL;
  list lIncStats = NIL;
  list lWriteStats = NIL;
 
  MAP(STATEMENT, loopStat,
  {
    entity oldInd = loop_index(statement_loop(loopStat));
 
    entity newInd =
      make_new_scalar_variable_with_prefix(entity_local_name(oldInd),
                                           get_current_module_entity(),
                                           copy_basic(entity_basic(oldInd)));
      AddEntityToCurrentModule(newInd);
 
    statement readStat = generate_ind_fifo_stat2(oldInd, newInd, true);
 
    lReadStats = CONS(STATEMENT, readStat, lReadStats);
 
    list addArg = gen_make_list(expression_domain,
                                entity_to_expression(newInd),
                                int_to_expression(1),
                                NULL);
 
    expression rExp =
      call_to_expression(make_call(get_function_entity(PLUS_OPERATOR_NAME),
                                   addArg));
 
    statement incStat = make_assign_statement(entity_to_expression(newInd), rExp);
 
    lIncStats = CONS(STATEMENT, incStat, lIncStats);
 
    statement writeStat = generate_ind_fifo_stat2(oldInd, newInd, false);
 
    lWriteStats = CONS(STATEMENT, writeStat, lWriteStats);
 
  }, glCurLoop);
 
  lStats = gen_nconc(lStats, lReadStats);
  lStats = gen_nconc(lStats, lIncStats);
  lStats = gen_nconc(lStats, lWriteStats);
 
  statement newStat = make_block_statement(lStats);
 
  fill_HRE_module(newStat);
}
#endif
 
/*
This function processes the HRE code generation for a
loop statement
 */
static statement HRE_distribute_loop(statement stat)
{
  //printf("HRE_distribute_loop beg\n");
 
  loop_enter();
 
  glCurLoop = CONS(STATEMENT, stat, glCurLoop);
 
  HRE_distribute_stat(loop_body(statement_loop(stat)), true);
 
  loop_enter();
 
  gen_remove(&glCurLoop, stat);
 
  //create_loop_HRE_module();
 
  return statement_undefined;
}
 
/*
This function processes the HRE code generation for a
call statement
 */
static statement HRE_distribute_call(statement stat)
{
  statement newStat = statement_undefined;
 
  list lCallRef = NIL;
  call curCall = instruction_call(statement_instruction(stat));
 
  MAP(EXPRESSION, exp,
  {
    list old = lCallRef;
    list new = NIL;
    new = comEngine_expression_to_reference_list(exp, new);
 
    lCallRef = gen_concatenate(old, new);
 
    gen_free_list(old);
    gen_free_list(new);
 
  }, call_arguments(curCall));
 
  glCurRep = gen_nconc(glCurRep, lCallRef);
 
  if(gIfCount == 0)
    {
      newStat = copy_statement(stat);
 
      statement_comments(newStat) = string_undefined;
    }
 
  return newStat;
}
 
/*
This function processes the HRE code generation for a
block statement
 */
static statement HRE_distribute_seq(statement stat)
{
  instruction instr = statement_instruction(stat);
 
  //printf("HRE_distribute_seq\n");
  MAP(STATEMENT, curStat,
  {
    statement seqStat = HRE_distribute_stat(curStat, false);
 
    //printf("seqStat\n");
    if(seqStat == statement_undefined)
      {
        //printf("undefined\n");
      }
    else
      {
        //print_statement(seqStat);
        if(gIfCount == 0)
          {
            gCurStats = gen_nconc(gCurStats, CONS(STATEMENT, seqStat, NIL));
          }
      }
 
  }, sequence_statements(instruction_sequence(instr)));
 
  return statement_undefined;
}
 
/*
This function processes the HRE code generation for a
test statement
 */
static statement HRE_distribute_test(statement stat)
{
  statement newStat = statement_undefined;
 
  list lCond = NIL;
  lCond =
    comEngine_expression_to_reference_list(test_condition(statement_test(stat)),
                                           lCond);
 
  glCurRep = gen_nconc(glCurRep, lCond);
 
  gIfCount++;
 
  // Generate the HRE code for the true statement
  HRE_distribute_stat(test_true(statement_test(stat)), true);
 
  // Generate the HRE code for the false statement
  HRE_distribute_stat(test_false(statement_test(stat)), true);
 
  gIfCount--;
 
  if(gIfCount == 0)
    {
      newStat = copy_statement(stat);
 
      statement_comments(newStat) = string_undefined;
    }
 
  return newStat;
}
 
/*
This function processes the HRE code generation for any
statements
 */
static statement HRE_distribute_stat(statement stat, bool calledFromLoop)
{
  statement newStat = statement_undefined;
 
  printf("HRE_distribute_stat\n");
  print_statement(stat);
 
  instruction instr = statement_instruction(stat);
 
  switch(instruction_tag(instr))
    {
    case is_instruction_sequence:
      {
        newStat = HRE_distribute_seq(stat);
 
        break;
      }
    case is_instruction_loop:
      {
        newStat = HRE_distribute_loop(stat);
        break;
      }
    case is_instruction_call:
      {
        newStat = HRE_distribute_call(stat);
 
        if(calledFromLoop && (gIfCount == 0))
          {
            gCurStats = gen_nconc(gCurStats, CONS(STATEMENT, newStat, NIL));
          }
 
        break;
      }
    case is_instruction_test:
      {
        newStat = HRE_distribute_test(stat);
 
        if(calledFromLoop && (gIfCount == 0))
          {
            gCurStats = gen_nconc(gCurStats, CONS(STATEMENT, newStat, NIL));
          }
 
        break;
      }
    default:
      {
        pips_assert("FALSE", false);
        break;
      }
    }
  printf("HRE_distribute_stat end\n");
  return newStat;
}
 
/*
This function generates the HRE code using several
processes on the HRE
 */
statement HRE_distribute(statement stat, string new_module_name, const char* module_name)
{
  printf("stat bef HRE_distribute\n");
  print_statement(stat);
 
  // Global variables initialization
  g_new_module_name = new_module_name;
  g_module_name = module_name;
  gCurStats = NIL;
  glCurRep = NIL;
  gIfCount = 0;
  glCurLoop = NIL;
  gNewInd = entity_undefined;
  gOldIndToNewInd = hash_table_make(hash_pointer, 0);
  gIsIndex = hash_table_make(hash_pointer, 0);
  glReadStats = NIL;
  glWriteStats = NIL;
 
  HRE_distribute_stat(stat, true);
 
  loop_enter();
 
  // Free some global variables
  hash_table_free(gOldIndToNewInd);
  hash_table_free(gIsIndex);
 
  return make_block_statement(NIL);
}