unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp

   1 //===---------------------- RemoteObjectLayerTest.cpp ---------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
  10 #include "llvm/ExecutionEngine/Orc/NullResolver.h"
  11 #include "llvm/ExecutionEngine/Orc/RemoteObjectLayer.h"
  12 #include "OrcTestCommon.h"
  13 #include "QueueChannel.h"
  14 #include "gtest/gtest.h"
  15
  16 using namespace llvm;
  17 using namespace llvm::orc;
  18
  19 namespace {
  20
  21 class MockObjectLayer {
  22 public:
  23
  24   using ObjHandleT = uint64_t;
  25
  26   using ObjectPtr = std::unique_ptr<MemoryBuffer>;
  27
  28   using LookupFn = std::function<JITSymbol(StringRef, bool)>;
  29   using SymbolLookupTable = std::map<ObjHandleT, LookupFn>;
  30
  31   using AddObjectFtor =
  32     std::function<Expected<ObjHandleT>(ObjectPtr, SymbolLookupTable&)>;
  33
  34   class ObjectNotFound : public remote::ResourceNotFound<ObjHandleT> {
  35   public:
  36     ObjectNotFound(ObjHandleT H) : ResourceNotFound(H, "Object handle") {}
  37   };
  38
  39   MockObjectLayer(AddObjectFtor AddObject)
  40     : AddObject(std::move(AddObject)) {}
  41
  42   Expected<ObjHandleT> addObject(ObjectPtr Obj,
  43             std::shared_ptr<JITSymbolResolver> Resolver) {
  44     return AddObject(std::move(Obj), SymTab);
  45   }
  46
  47   Error removeObject(ObjHandleT H) {
  48     if (SymTab.count(H))
  49       return Error::success();
  50     else
  51       return make_error<ObjectNotFound>(H);
  52   }
  53
  54   JITSymbol findSymbol(StringRef Name, bool ExportedSymbolsOnly) {
  55     for (auto KV : SymTab) {
  56       if (auto Sym = KV.second(Name, ExportedSymbolsOnly))
  57         return Sym;
  58       else if (auto Err = Sym.takeError())
  59         return std::move(Err);
  60     }
  61     return JITSymbol(nullptr);
  62   }
  63
  64   JITSymbol findSymbolIn(ObjHandleT H, StringRef Name,
  65                          bool ExportedSymbolsOnly) {
  66     auto LI = SymTab.find(H);
  67     if (LI != SymTab.end())
  68       return LI->second(Name, ExportedSymbolsOnly);
  69     else
  70       return make_error<ObjectNotFound>(H);
  71   }
  72
  73   Error emitAndFinalize(ObjHandleT H) {
  74     if (SymTab.count(H))
  75       return Error::success();
  76     else
  77       return make_error<ObjectNotFound>(H);
  78   }
  79
  80 private:
  81   AddObjectFtor AddObject;
  82   SymbolLookupTable SymTab;
  83 };
  84
  85 using RPCEndpoint = rpc::SingleThreadedRPCEndpoint<rpc::RawByteChannel>;
  86
  87 MockObjectLayer::ObjectPtr createTestObject() {
  88   OrcNativeTarget::initialize();
  89   auto TM = std::unique_ptr<TargetMachine>(EngineBuilder().selectTarget());
  90
  91   if (!TM)
  92     return nullptr;
  93
  94   LLVMContext Ctx;
  95   ModuleBuilder MB(Ctx, TM->getTargetTriple().str(), "TestModule");
  96   MB.getModule()->setDataLayout(TM->createDataLayout());
  97   auto *Main = MB.createFunctionDecl(
  98       FunctionType::get(Type::getInt32Ty(Ctx),
  99                         {Type::getInt32Ty(Ctx),
 100                          Type::getInt8PtrTy(Ctx)->getPointerTo()},
 101                         false),
 102       "main");
 103   Main->getBasicBlockList().push_back(BasicBlock::Create(Ctx));
 104   IRBuilder<> B(&Main->back());
 105   B.CreateRet(ConstantInt::getSigned(Type::getInt32Ty(Ctx), 42));
 106
 107   SimpleCompiler IRCompiler(*TM);
 108   return IRCompiler(*MB.getModule());
 109 }
 110
 111 TEST(RemoteObjectLayer, AddObject) {
 112   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 113   auto TestObject = createTestObject();
 114   if (!TestObject)
 115     return;
 116
 117   auto Channels = createPairedQueueChannels();
 118
 119   auto ReportError = [](Error Err) {
 120     logAllUnhandledErrors(std::move(Err), llvm::errs());
 121   };
 122
 123   // Copy the bytes out of the test object: the copy will be used to verify
 124   // that the original is correctly transmitted over RPC to the mock layer.
 125   StringRef ObjBytes = TestObject->getBuffer();
 126   std::vector<char> ObjContents(ObjBytes.size());
 127   std::copy(ObjBytes.begin(), ObjBytes.end(), ObjContents.begin());
 128
 129   RPCEndpoint ClientEP(*Channels.first, true);
 130   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 131                                               ClientEP, ReportError);
 132
 133   RPCEndpoint ServerEP(*Channels.second, true);
 134   MockObjectLayer BaseLayer(
 135     [&ObjContents](MockObjectLayer::ObjectPtr Obj,
 136                    MockObjectLayer::SymbolLookupTable &SymTab) {
 137
 138       // Check that the received object file content matches the original.
 139       StringRef RPCObjContents = Obj->getBuffer();
 140       EXPECT_EQ(RPCObjContents.size(), ObjContents.size())
 141         << "RPC'd object file has incorrect size";
 142       EXPECT_TRUE(std::equal(RPCObjContents.begin(), RPCObjContents.end(),
 143                              ObjContents.begin()))
 144         << "RPC'd object file content does not match original content";
 145
 146       return 1;
 147     });
 148   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 149       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 150
 151   bool Finished = false;
 152   ServerEP.addHandler<remote::utils::TerminateSession>(
 153     [&]() { Finished = true; }
 154   );
 155
 156   auto ServerThread =
 157     std::thread([&]() {
 158       while (!Finished)
 159         cantFail(ServerEP.handleOne());
 160     });
 161
 162   cantFail(Client.addObject(std::move(TestObject),
 163                             std::make_shared<NullLegacyResolver>()));
 164   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 165   ServerThread.join();
 166 }
 167
 168 TEST(RemoteObjectLayer, AddObjectFailure) {
 169   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 170   auto TestObject = createTestObject();
 171   if (!TestObject)
 172     return;
 173
 174   auto Channels = createPairedQueueChannels();
 175
 176   auto ReportError =
 177     [](Error Err) {
 178       auto ErrMsg = toString(std::move(Err));
 179       EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
 180         << "Expected error string to be \"AddObjectFailure - Test Message\"";
 181     };
 182
 183   RPCEndpoint ClientEP(*Channels.first, true);
 184   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 185                                               ClientEP, ReportError);
 186
 187   RPCEndpoint ServerEP(*Channels.second, true);
 188   MockObjectLayer BaseLayer(
 189     [](MockObjectLayer::ObjectPtr Obj,
 190        MockObjectLayer::SymbolLookupTable &SymTab)
 191         -> Expected<MockObjectLayer::ObjHandleT> {
 192       return make_error<StringError>("AddObjectFailure - Test Message",
 193                                      inconvertibleErrorCode());
 194     });
 195   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 196       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 197
 198   bool Finished = false;
 199   ServerEP.addHandler<remote::utils::TerminateSession>(
 200     [&]() { Finished = true; }
 201   );
 202
 203   auto ServerThread =
 204     std::thread([&]() {
 205       while (!Finished)
 206         cantFail(ServerEP.handleOne());
 207     });
 208
 209   auto HandleOrErr = Client.addObject(std::move(TestObject),
 210                                       std::make_shared<NullLegacyResolver>());
 211
 212   EXPECT_FALSE(HandleOrErr) << "Expected error from addObject";
 213
 214   auto ErrMsg = toString(HandleOrErr.takeError());
 215   EXPECT_EQ(ErrMsg, "AddObjectFailure - Test Message")
 216     << "Expected error string to be \"AddObjectFailure - Test Message\"";
 217
 218   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 219   ServerThread.join();
 220 }
 221
 222
 223 TEST(RemoteObjectLayer, RemoveObject) {
 224   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 225   auto TestObject = createTestObject();
 226   if (!TestObject)
 227     return;
 228
 229   auto Channels = createPairedQueueChannels();
 230
 231   auto ReportError = [](Error Err) {
 232     logAllUnhandledErrors(std::move(Err), llvm::errs());
 233   };
 234
 235   RPCEndpoint ClientEP(*Channels.first, true);
 236   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 237                                               ClientEP, ReportError);
 238
 239   RPCEndpoint ServerEP(*Channels.second, true);
 240
 241   MockObjectLayer BaseLayer(
 242     [](MockObjectLayer::ObjectPtr Obj,
 243        MockObjectLayer::SymbolLookupTable &SymTab) {
 244       SymTab[1] = MockObjectLayer::LookupFn();
 245       return 1;
 246     });
 247   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 248       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 249
 250   bool Finished = false;
 251   ServerEP.addHandler<remote::utils::TerminateSession>(
 252     [&]() { Finished = true; }
 253   );
 254
 255   auto ServerThread =
 256     std::thread([&]() {
 257       while (!Finished)
 258         cantFail(ServerEP.handleOne());
 259     });
 260
 261   auto H = cantFail(Client.addObject(std::move(TestObject),
 262                                      std::make_shared<NullLegacyResolver>()));
 263
 264   cantFail(Client.removeObject(H));
 265
 266   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 267   ServerThread.join();
 268 }
 269
 270 TEST(RemoteObjectLayer, RemoveObjectFailure) {
 271   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 272   auto TestObject = createTestObject();
 273   if (!TestObject)
 274     return;
 275
 276   auto Channels = createPairedQueueChannels();
 277
 278   auto ReportError =
 279     [](Error Err) {
 280       auto ErrMsg = toString(std::move(Err));
 281       EXPECT_EQ(ErrMsg, "Object handle 42 not found")
 282         << "Expected error string to be \"Object handle 42 not found\"";
 283     };
 284
 285   RPCEndpoint ClientEP(*Channels.first, true);
 286   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 287                                               ClientEP, ReportError);
 288
 289   RPCEndpoint ServerEP(*Channels.second, true);
 290
 291   // AddObject lambda does not update symbol table, so removeObject will treat
 292   // this as a bad object handle.
 293   MockObjectLayer BaseLayer(
 294     [](MockObjectLayer::ObjectPtr Obj,
 295        MockObjectLayer::SymbolLookupTable &SymTab) {
 296       return 42;
 297     });
 298   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 299       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 300
 301   bool Finished = false;
 302   ServerEP.addHandler<remote::utils::TerminateSession>(
 303     [&]() { Finished = true; }
 304   );
 305
 306   auto ServerThread =
 307     std::thread([&]() {
 308       while (!Finished)
 309         cantFail(ServerEP.handleOne());
 310     });
 311
 312   auto H = cantFail(Client.addObject(std::move(TestObject),
 313                                      std::make_shared<NullLegacyResolver>()));
 314
 315   auto Err = Client.removeObject(H);
 316   EXPECT_TRUE(!!Err) << "Expected error from removeObject";
 317
 318   auto ErrMsg = toString(std::move(Err));
 319   EXPECT_EQ(ErrMsg, "Object handle 42 not found")
 320     << "Expected error string to be \"Object handle 42 not found\"";
 321
 322   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 323   ServerThread.join();
 324 }
 325
 326 TEST(RemoteObjectLayer, FindSymbol) {
 327   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 328   auto TestObject = createTestObject();
 329   if (!TestObject)
 330     return;
 331
 332   auto Channels = createPairedQueueChannels();
 333
 334   auto ReportError =
 335     [](Error Err) {
 336       auto ErrMsg = toString(std::move(Err));
 337       EXPECT_EQ(ErrMsg, "Could not find symbol 'badsymbol'")
 338         << "Expected error string to be \"Object handle 42 not found\"";
 339     };
 340
 341   RPCEndpoint ClientEP(*Channels.first, true);
 342   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 343                                               ClientEP, ReportError);
 344
 345   RPCEndpoint ServerEP(*Channels.second, true);
 346
 347   // AddObject lambda does not update symbol table, so removeObject will treat
 348   // this as a bad object handle.
 349   MockObjectLayer BaseLayer(
 350     [](MockObjectLayer::ObjectPtr Obj,
 351        MockObjectLayer::SymbolLookupTable &SymTab) {
 352       SymTab[42] =
 353         [](StringRef Name, bool ExportedSymbolsOnly) -> JITSymbol {
 354           if (Name == "foobar")
 355             return JITSymbol(0x12348765, JITSymbolFlags::Exported);
 356           if (Name == "badsymbol")
 357             return make_error<JITSymbolNotFound>(Name);
 358           return nullptr;
 359         };
 360       return 42;
 361     });
 362   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 363       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 364
 365   bool Finished = false;
 366   ServerEP.addHandler<remote::utils::TerminateSession>(
 367     [&]() { Finished = true; }
 368   );
 369
 370   auto ServerThread =
 371     std::thread([&]() {
 372       while (!Finished)
 373         cantFail(ServerEP.handleOne());
 374     });
 375
 376   cantFail(Client.addObject(std::move(TestObject),
 377                             std::make_shared<NullLegacyResolver>()));
 378
 379   // Check that we can find and materialize a valid symbol.
 380   auto Sym1 = Client.findSymbol("foobar", true);
 381   EXPECT_TRUE(!!Sym1) << "Symbol 'foobar' should be findable";
 382   EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
 383     << "Symbol 'foobar' does not return the correct address";
 384
 385   {
 386     // Check that we can return a symbol containing an error.
 387     auto Sym2 = Client.findSymbol("badsymbol", true);
 388     EXPECT_FALSE(!!Sym2) << "Symbol 'badsymbol' should not be findable";
 389     auto Err = Sym2.takeError();
 390     EXPECT_TRUE(!!Err) << "Sym2 should contain an error value";
 391     auto ErrMsg = toString(std::move(Err));
 392     EXPECT_EQ(ErrMsg, "Could not find symbol 'badsymbol'")
 393       << "Expected symbol-not-found error for Sym2";
 394   }
 395
 396   {
 397     // Check that we can return a 'null' symbol.
 398     auto Sym3 = Client.findSymbol("baz", true);
 399     EXPECT_FALSE(!!Sym3) << "Symbol 'baz' should convert to false";
 400     auto Err = Sym3.takeError();
 401     EXPECT_FALSE(!!Err) << "Symbol 'baz' should not contain an error";
 402   }
 403
 404   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 405   ServerThread.join();
 406 }
 407
 408 TEST(RemoteObjectLayer, FindSymbolIn) {
 409   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 410   auto TestObject = createTestObject();
 411   if (!TestObject)
 412     return;
 413
 414   auto Channels = createPairedQueueChannels();
 415
 416   auto ReportError =
 417     [](Error Err) {
 418       auto ErrMsg = toString(std::move(Err));
 419       EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
 420         << "Expected error string to be \"Object handle 42 not found\"";
 421     };
 422
 423   RPCEndpoint ClientEP(*Channels.first, true);
 424   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 425                                               ClientEP, ReportError);
 426
 427   RPCEndpoint ServerEP(*Channels.second, true);
 428
 429   // AddObject lambda does not update symbol table, so removeObject will treat
 430   // this as a bad object handle.
 431   MockObjectLayer BaseLayer(
 432     [](MockObjectLayer::ObjectPtr Obj,
 433        MockObjectLayer::SymbolLookupTable &SymTab) {
 434       SymTab[42] =
 435         [](StringRef Name, bool ExportedSymbolsOnly) -> JITSymbol {
 436           if (Name == "foobar")
 437             return JITSymbol(0x12348765, JITSymbolFlags::Exported);
 438           return make_error<JITSymbolNotFound>(Name);
 439         };
 440       // Dummy symbol table entry - this should not be visible to
 441       // findSymbolIn.
 442       SymTab[43] =
 443         [](StringRef Name, bool ExportedSymbolsOnly) -> JITSymbol {
 444           if (Name == "barbaz")
 445             return JITSymbol(0xdeadbeef, JITSymbolFlags::Exported);
 446           return make_error<JITSymbolNotFound>(Name);
 447         };
 448
 449       return 42;
 450     });
 451   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 452       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 453
 454   bool Finished = false;
 455   ServerEP.addHandler<remote::utils::TerminateSession>(
 456     [&]() { Finished = true; }
 457   );
 458
 459   auto ServerThread =
 460     std::thread([&]() {
 461       while (!Finished)
 462         cantFail(ServerEP.handleOne());
 463     });
 464
 465   auto H = cantFail(Client.addObject(std::move(TestObject),
 466                                      std::make_shared<NullLegacyResolver>()));
 467
 468   auto Sym1 = Client.findSymbolIn(H, "foobar", true);
 469
 470   EXPECT_TRUE(!!Sym1) << "Symbol 'foobar' should be findable";
 471   EXPECT_EQ(cantFail(Sym1.getAddress()), 0x12348765ULL)
 472     << "Symbol 'foobar' does not return the correct address";
 473
 474   auto Sym2 = Client.findSymbolIn(H, "barbaz", true);
 475   EXPECT_FALSE(!!Sym2) << "Symbol 'barbaz' should not be findable";
 476   auto Err = Sym2.takeError();
 477   EXPECT_TRUE(!!Err) << "Sym2 should contain an error value";
 478   auto ErrMsg = toString(std::move(Err));
 479   EXPECT_EQ(ErrMsg, "Could not find symbol 'barbaz'")
 480     << "Expected symbol-not-found error for Sym2";
 481
 482   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 483   ServerThread.join();
 484 }
 485
 486 TEST(RemoteObjectLayer, EmitAndFinalize) {
 487   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 488   auto TestObject = createTestObject();
 489   if (!TestObject)
 490     return;
 491
 492   auto Channels = createPairedQueueChannels();
 493
 494   auto ReportError = [](Error Err) {
 495     logAllUnhandledErrors(std::move(Err), llvm::errs());
 496   };
 497
 498   RPCEndpoint ClientEP(*Channels.first, true);
 499   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 500                                               ClientEP, ReportError);
 501
 502   RPCEndpoint ServerEP(*Channels.second, true);
 503
 504   MockObjectLayer BaseLayer(
 505     [](MockObjectLayer::ObjectPtr Obj,
 506        MockObjectLayer::SymbolLookupTable &SymTab) {
 507       SymTab[1] = MockObjectLayer::LookupFn();
 508       return 1;
 509     });
 510   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 511       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 512
 513   bool Finished = false;
 514   ServerEP.addHandler<remote::utils::TerminateSession>(
 515     [&]() { Finished = true; }
 516   );
 517
 518   auto ServerThread =
 519     std::thread([&]() {
 520       while (!Finished)
 521         cantFail(ServerEP.handleOne());
 522     });
 523
 524   auto H = cantFail(Client.addObject(std::move(TestObject),
 525                                      std::make_shared<NullLegacyResolver>()));
 526
 527   auto Err = Client.emitAndFinalize(H);
 528   EXPECT_FALSE(!!Err) << "emitAndFinalize should work";
 529
 530   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 531   ServerThread.join();
 532 }
 533
 534 TEST(RemoteObjectLayer, EmitAndFinalizeFailure) {
 535   llvm::orc::rpc::registerStringError<rpc::RawByteChannel>();
 536   auto TestObject = createTestObject();
 537   if (!TestObject)
 538     return;
 539
 540   auto Channels = createPairedQueueChannels();
 541
 542   auto ReportError =
 543     [](Error Err) {
 544       auto ErrMsg = toString(std::move(Err));
 545       EXPECT_EQ(ErrMsg, "Object handle 1 not found")
 546         << "Expected bad handle error";
 547     };
 548
 549   RPCEndpoint ClientEP(*Channels.first, true);
 550   RemoteObjectClientLayer<RPCEndpoint> Client(AcknowledgeORCv1Deprecation,
 551                                               ClientEP, ReportError);
 552
 553   RPCEndpoint ServerEP(*Channels.second, true);
 554
 555   MockObjectLayer BaseLayer(
 556     [](MockObjectLayer::ObjectPtr Obj,
 557        MockObjectLayer::SymbolLookupTable &SymTab) {
 558       return 1;
 559     });
 560   RemoteObjectServerLayer<MockObjectLayer, RPCEndpoint> Server(
 561       AcknowledgeORCv1Deprecation, BaseLayer, ServerEP, ReportError);
 562
 563   bool Finished = false;
 564   ServerEP.addHandler<remote::utils::TerminateSession>(
 565     [&]() { Finished = true; }
 566   );
 567
 568   auto ServerThread =
 569     std::thread([&]() {
 570       while (!Finished)
 571         cantFail(ServerEP.handleOne());
 572     });
 573
 574   auto H = cantFail(Client.addObject(std::move(TestObject),
 575                                      std::make_shared<NullLegacyResolver>()));
 576
 577   auto Err = Client.emitAndFinalize(H);
 578   EXPECT_TRUE(!!Err) << "emitAndFinalize should work";
 579
 580   auto ErrMsg = toString(std::move(Err));
 581   EXPECT_EQ(ErrMsg, "Object handle 1 not found")
 582     << "emitAndFinalize returned incorrect error";
 583
 584   cantFail(ClientEP.callB<remote::utils::TerminateSession>());
 585   ServerThread.join();
 586 }
 587
 588 }