[OPENMP] Codegen of the ‘aligned’ clause for the ‘omp simd’ directive

[amusman]

Summary

Please review codegen of the ‘aligned’ clause for the ‘omp simd’ directive.
It uses @llvm.assume intrinsic to specify alignment hints in LLVM IR.

[hfinkel]

include/clang/Basic/DiagnosticSemaKinds.td

7180

I don't like the " - ignored" part, how about rewording like this:

"aligned clause will be ignored because the requested alignment is not a power of 2"

lib/CodeGen/CGStmtOpenMP.cpp

54

Remove this (see below).

77

I don't think that using Safelen here is the right thing to do; a loop can have a very large safelen without that implying anything about the alignment of the pointers.

The right thing to do here is to use a callback into TargetCodeGenInfo (which you can get at using the TheTargetCodeGenInfo global).

96

Remove the FIXME.

[amusman]

Hi Hal,

Thank you for review, I've fixed your comments. Here is updated version.
I added method getOpenMPSimdDefaultAlignment to TheTargetCodeGenInfo (implemented it for x86_64 only for now).

Regards,
Alexander

[hfinkel]

lib/CodeGen/CGStmtOpenMP.cpp

64

I think that you should just assert that this is either a power of 2 (or zero): if a target starts returning some other kind of number, that would be a bug, and we'd want to know.

69

As I also mention below, when we use a default alignment, I'll need that to depend on the type, so you'll need to rearrange things here slightly.

95

You don't need the {} here.

lib/CodeGen/TargetInfo.h

223

I don't really like this description; how about this:

/// Gets the target-specific default alignment used when an 'aligned' clause is used with a 'simd' OpenMP directive without specifying a specific alignment.

224

In general, I'll need this to depend on the type; please add a type parameter.

[amusman]

Hal,

Here is updated patch, I added type parameter to getOpenMPSimdDefaultAlignment (I guess you meant llvm::Type, not clang::Type) and fixed other issues.

Thanks,
Alexander

[hfinkel]

I added type parameter to getOpenMPSimdDefaultAlignment (I guess you meant llvm::Type, not clang::Type)

I think I'd actually like the QualType (which I suppose is just E->getType()), so that pointers to single-element structures can be handled like pointers to the underlying type in a straightforward way (meaning using the same logic that already exists in the ABI code).

Otherwise, LGTM. Thanks!

[amusman]

Closed by commit rL218660 (authored by @amusman).

include/clang/Basic/DiagnosticSemaKinds.td

 def err_omp_linear_incomplete_type : Error<
   "a linear variable with incomplete type %0">;
 def err_omp_linear_expected_int_or_ptr : Error<
   "argument of a linear clause should be of integral or pointer "
   "type, not %0">;
 def warn_omp_linear_step_zero : Warning<
   "zero linear step (%0 %select{|and other variables in clause }1should probably be const)">,
   InGroup<OpenMPClauses>;
+def warn_omp_alignment_not_power_of_two : Warning<
+  "aligned clause will be ignored because the requested alignment is not a power of 2">,
+  InGroup<OpenMPClauses>;
 def err_omp_aligned_expected_array_or_ptr : Error<
   "argument of aligned clause should be array"
   "%select{ or pointer|, pointer, reference to array or reference to pointer}1"
   ", not %0">;
 def err_omp_aligned_twice : Error<
   "a variable cannot appear in more than one aligned clause">;
 def err_omp_local_var_in_threadprivate_init : Error<
   "variable with local storage in initial value of threadprivate variable">;

lib/CodeGen/CGStmtOpenMP.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "CGOpenMPRuntime.h"
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtOpenMP.h"
+#include "TargetInfo.h"
 using namespace clang;
 using namespace CodeGen;
 
 //===----------------------------------------------------------------------===//
 //                              OpenMP Directive Emission
 //===----------------------------------------------------------------------===//
 
 void CodeGenFunction::EmitOMPParallelDirective(const OMPParallelDirective &S) {
llvm::Value *Args[] = {
       Builder.CreateBitCast(OutlinedFn,
                             CGM.getOpenMPRuntime().getKmpc_MicroPointerTy()),
       EmitCastToVoidPtr(CapturedStruct)};
   llvm::Constant *RTLFn = CGM.getOpenMPRuntime().CreateRuntimeFunction(
       CGOpenMPRuntime::OMPRTL__kmpc_fork_call);
   EmitRuntimeCall(RTLFn, Args);
 }
 
+static void EmitOMPAlignedClause(CodeGenFunction &CGF, CodeGenModule &CGM,
+                                 const OMPAlignedClause &Clause) {
+  unsigned ClauseAlignment = 0;
+  if (auto AlignmentExpr = Clause.getAlignment()) {
+    auto AlignmentCI =
+        cast<llvm::ConstantInt>(CGF.EmitScalarExpr(AlignmentExpr));
+    ClauseAlignment = static_cast<unsigned>(AlignmentCI->getZExtValue());
+  }
+  for (auto E : Clause.varlists()) {
+    llvm::Value *PtrValue = CGF.EmitScalarExpr(E);
+    unsigned Alignment = ClauseAlignment;
+    if (Alignment == 0) {
+      // OpenMP [2.8.1, Description]
+      // If no optional parameter isspecified, implementation-defined default
+      // alignments for SIMD instructions on the target platforms are assumed.
+      Alignment = CGM.getTargetCodeGenInfo().getOpenMPSimdDefaultAlignment(
+          PtrValue->getType());
+    }
+    assert((Alignment == 0 || llvm::isPowerOf2_32(Alignment)) &&
+           "alignment is not power of 2");
+    if (Alignment != 0)
+      CGF.EmitAlignmentAssumption(PtrValue, Alignment);
+  }
+}
+
 void CodeGenFunction::EmitOMPSimdDirective(const OMPSimdDirective &S) {
   const CapturedStmt *CS = cast<CapturedStmt>(S.getAssociatedStmt());
   const Stmt *Body = CS->getCapturedStmt();
   LoopStack.setParallel();
   LoopStack.setVectorizerEnable(true);
   for (auto C : S.clauses()) {
     switch (C->getClauseKind()) {
     case OMPC_safelen: {
       RValue Len = EmitAnyExpr(cast<OMPSafelenClause>(C)->getSafelen(),
                                AggValueSlot::ignored(), true);
       llvm::ConstantInt *Val = cast<llvm::ConstantInt>(Len.getScalarVal());
       LoopStack.setVectorizerWidth(Val->getZExtValue());
       // In presence of finite 'safelen', it may be unsafe to mark all
       // the memory instructions parallel, because loop-carried
       // dependences of 'safelen' iterations are possible.
       LoopStack.setParallel(false);
       break;
     }
+    case OMPC_aligned:
+      EmitOMPAlignedClause(*this, CGM, cast<OMPAlignedClause>(*C));
+      break;
     default:
       // Not handled yet
       ;
     }
   }
   EmitStmt(Body);
 }
 

lib/CodeGen/TargetInfo.h

public:
   virtual void getDependentLibraryOption(llvm::StringRef Lib,
                                          llvm::SmallString<24> &Opt) const;
 
   /// Gets the linker options necessary to detect object file mismatches on
   /// this platform.
   virtual void getDetectMismatchOption(llvm::StringRef Name,
                                        llvm::StringRef Value,
                                        llvm::SmallString<32> &Opt) const {}
+
+  /// Gets the target-specific default alignment used when an 'aligned' clause
+  /// is used with a 'simd' OpenMP directive without specifying a specific
+  /// alignment.
+  virtual unsigned getOpenMPSimdDefaultAlignment(llvm::Type *Ty) const {
+    return 0;
+  }
 };
 }
 
 #endif

lib/CodeGen/TargetInfo.cpp

public:
 
   void computeInfo(CGFunctionInfo &FI) const override;
 
   llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
                          CodeGenFunction &CGF) const override;
 };
 
 class X86_64TargetCodeGenInfo : public TargetCodeGenInfo {
+  bool HasAVX;
 public:
   X86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX)
-      : TargetCodeGenInfo(new X86_64ABIInfo(CGT, HasAVX)) {}
+      : TargetCodeGenInfo(new X86_64ABIInfo(CGT, HasAVX)), HasAVX(HasAVX) {}
 
   const X86_64ABIInfo &getABIInfo() const {
     return static_cast<const X86_64ABIInfo&>(TargetCodeGenInfo::getABIInfo());
   }
 
   int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
     return 7;
   }
public:
   getUBSanFunctionSignature(CodeGen::CodeGenModule &CGM) const override {
     unsigned Sig = (0xeb << 0) |  // jmp rel8
                    (0x0a << 8) |  //           .+0x0c
                    ('F' << 16) |
                    ('T' << 24);
     return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
   }
 
+  unsigned getOpenMPSimdDefaultAlignment(llvm::Type *) const override {
+    return HasAVX ? 32 : 16;
+  }
 };
 
 static std::string qualifyWindowsLibrary(llvm::StringRef Lib) {
   // If the argument does not end in .lib, automatically add the suffix. This
   // matches the behavior of MSVC.
   std::string ArgStr = Lib;
   if (!Lib.endswith_lower(".lib"))
     ArgStr += ".lib";
public:
   void getDetectMismatchOption(llvm::StringRef Name,
                                llvm::StringRef Value,
                                llvm::SmallString<32> &Opt) const override {
     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
   }
 };
 
 class WinX86_64TargetCodeGenInfo : public TargetCodeGenInfo {
+  bool HasAVX;
 public:
-  WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT)
-    : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)) {}
+  WinX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX)
+    : TargetCodeGenInfo(new WinX86_64ABIInfo(CGT)), HasAVX(HasAVX) {}
 
   int getDwarfEHStackPointer(CodeGen::CodeGenModule &CGM) const override {
     return 7;
   }
 
   bool initDwarfEHRegSizeTable(CodeGen::CodeGenFunction &CGF,
                                llvm::Value *Address) const override {
     llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
void getDependentLibraryOption(llvm::StringRef Lib,
     Opt += qualifyWindowsLibrary(Lib);
   }
 
   void getDetectMismatchOption(llvm::StringRef Name,
                                llvm::StringRef Value,
                                llvm::SmallString<32> &Opt) const override {
     Opt = "/FAILIFMISMATCH:\"" + Name.str() + "=" + Value.str() + "\"";
   }
+
+  unsigned getOpenMPSimdDefaultAlignment(llvm::Type *) const override {
+    return HasAVX ? 32 : 16;
+  }
 };
 
 }
 
 void X86_64ABIInfo::postMerge(unsigned AggregateSize, Class &Lo,
                               Class &Hi) const {
   // AMD64-ABI 3.2.3p2: Rule 5. Then a post merger cleanup is done:
   //
public:
   llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
                          CodeGenFunction &CGF) const override;
  private:
   PNaClABIInfo PInfo;  // Used for generating calls with pnaclcall callingconv.
   X86_64ABIInfo NInfo; // Used for everything else.
 };
 
 class NaClX86_64TargetCodeGenInfo : public TargetCodeGenInfo  {
+  bool HasAVX;
  public:
    NaClX86_64TargetCodeGenInfo(CodeGen::CodeGenTypes &CGT, bool HasAVX)
-      : TargetCodeGenInfo(new NaClX86_64ABIInfo(CGT, HasAVX)) {}
+       : TargetCodeGenInfo(new NaClX86_64ABIInfo(CGT, HasAVX)), HasAVX(HasAVX) {
+   }
+   unsigned getOpenMPSimdDefaultAlignment(llvm::Type *) const override {
+     return HasAVX ? 32 : 16;
+   }
 };
 
 }
 
 void NaClX86_64ABIInfo::computeInfo(CGFunctionInfo &FI) const {
   if (FI.getASTCallingConvention() == CC_PnaclCall)
     PInfo.computeInfo(FI);
   else
case llvm::Triple::x86: {
     }
   }
 
   case llvm::Triple::x86_64: {
     bool HasAVX = getTarget().getABI() == "avx";
 
     switch (Triple.getOS()) {
     case llvm::Triple::Win32:
-      return *(TheTargetCodeGenInfo = new WinX86_64TargetCodeGenInfo(Types));
+      return *(TheTargetCodeGenInfo =
+                   new WinX86_64TargetCodeGenInfo(Types, HasAVX));
     case llvm::Triple::NaCl:
-      return *(TheTargetCodeGenInfo = new NaClX86_64TargetCodeGenInfo(Types,
-                                                                      HasAVX));
+      return *(TheTargetCodeGenInfo =
+                   new NaClX86_64TargetCodeGenInfo(Types, HasAVX));
     default:
-      return *(TheTargetCodeGenInfo = new X86_64TargetCodeGenInfo(Types,
-                                                                  HasAVX));
+      return *(TheTargetCodeGenInfo =
+                   new X86_64TargetCodeGenInfo(Types, HasAVX));
     }
   }
   case llvm::Triple::hexagon:
     return *(TheTargetCodeGenInfo = new HexagonTargetCodeGenInfo(Types));
   case llvm::Triple::sparcv9:
     return *(TheTargetCodeGenInfo = new SparcV9TargetCodeGenInfo(Types));
   case llvm::Triple::xcore:
     return *(TheTargetCodeGenInfo = new XCoreTargetCodeGenInfo(Types));
   }
 }

lib/Sema/SemaOpenMP.cpp

ExprResult Sema::VerifyPositiveIntegerConstantInClause(Expr *E,
   ExprResult ICE = VerifyIntegerConstantExpression(E, &Result);
   if (ICE.isInvalid())
     return ExprError();
   if (!Result.isStrictlyPositive()) {
     Diag(E->getExprLoc(), diag::err_omp_negative_expression_in_clause)
         << getOpenMPClauseName(CKind) << E->getSourceRange();
     return ExprError();
   }
+  if (CKind == OMPC_aligned && !Result.isPowerOf2()) {
+    Diag(E->getExprLoc(), diag::warn_omp_alignment_not_power_of_two)
+        << E->getSourceRange();
+    return ExprError();
+  }
   return ICE;
 }
 
 OMPClause *Sema::ActOnOpenMPSafelenClause(Expr *Len, SourceLocation StartLoc,
                                           SourceLocation LParenLoc,
                                           SourceLocation EndLoc) {
   // OpenMP [2.8.1, simd construct, Description]
   // The parameter of the safelen clause must be a constant

test/OpenMP/for_simd_aligned_messages.cpp

void test_aligned_colons(int *&rp)
   // expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}}
   #pragma omp for simd aligned(B,rp,::z: X::x)
   for (int i = 0; i < 10; ++i) ;
   #pragma omp for simd aligned(::z)
   for (int i = 0; i < 10; ++i) ;
   // expected-error@+1 {{expected variable name}}
   #pragma omp for simd aligned(B::bfoo())
   for (int i = 0; i < 10; ++i) ;
+  // expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}}
   #pragma omp for simd aligned(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
 }
 
 // expected-note@+1 {{'num' defined here}}
 template<int L, class T, class N> T test_template(T* arr, N num) {
   N i;
   T sum = (T)0;
template<class I, class C> int foomain(I argc, C **argv) {
   #pragma omp for simd aligned () // expected-error {{expected expression}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp for simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (I k = 0; k < argc; ++k) ++k;
-  #pragma omp for simd aligned (argc : 5)
+  #pragma omp for simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp for simd aligned (S1) // expected-error {{'S1' does not refer to a value}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp for simd aligned (argv[1]) // expected-error {{expected variable name}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp for simd aligned(e, g)
   for (I k = 0; k < argc; ++k) ++k;
   // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}}

test/OpenMP/parallel_for_simd_aligned_messages.cpp

void test_aligned_colons(int *&rp)
   // expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}}
   #pragma omp parallel for simd aligned(B,rp,::z: X::x)
   for (int i = 0; i < 10; ++i) ;
   #pragma omp parallel for simd aligned(::z)
   for (int i = 0; i < 10; ++i) ;
   // expected-error@+1 {{expected variable name}}
   #pragma omp parallel for simd aligned(B::bfoo())
   for (int i = 0; i < 10; ++i) ;
+  // expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}}
   #pragma omp parallel for simd aligned(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
 }
 
 // expected-note@+1 {{'num' defined here}}
 template<int L, class T, class N> T test_template(T* arr, N num) {
   N i;
   T sum = (T)0;
template<class I, class C> int foomain(I argc, C **argv) {
   #pragma omp parallel for simd aligned () // expected-error {{expected expression}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp parallel for simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp parallel for simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp parallel for simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (I k = 0; k < argc; ++k) ++k;
-  #pragma omp parallel for simd aligned (argc : 5)
+  #pragma omp parallel for simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp parallel for simd aligned (S1) // expected-error {{'S1' does not refer to a value}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp parallel for simd aligned (argv[1]) // expected-error {{expected variable name}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp parallel for simd aligned(e, g)
   for (I k = 0; k < argc; ++k) ++k;
   // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}}

test/OpenMP/simd_aligned_messages.cpp

void test_aligned_colons(int *&rp)
   // expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}}
   #pragma omp simd aligned(B,rp,::z: X::x)
   for (int i = 0; i < 10; ++i) ;
   #pragma omp simd aligned(::z)
   for (int i = 0; i < 10; ++i) ;
   // expected-error@+1 {{expected variable name}}
   #pragma omp simd aligned(B::bfoo())
   for (int i = 0; i < 10; ++i) ;
+  // expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}}
   #pragma omp simd aligned(B::ib,B:C1+C2)
   for (int i = 0; i < 10; ++i) ;
 }
 
 // expected-note@+1 {{'num' defined here}}
 template<int L, class T, class N> T test_template(T* arr, N num) {
   N i;
   T sum = (T)0;
template<class I, class C> int foomain(I argc, C **argv) {
   #pragma omp simd aligned () // expected-error {{expected expression}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
   for (I k = 0; k < argc; ++k) ++k;
-  #pragma omp simd aligned (argc : 5)
+  #pragma omp simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp simd aligned (S1) // expected-error {{'S1' does not refer to a value}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp simd aligned (argv[1]) // expected-error {{expected variable name}}
   for (I k = 0; k < argc; ++k) ++k;
   #pragma omp simd aligned(e, g)
   for (I k = 0; k < argc; ++k) ++k;
   // expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}}

test/OpenMP/simd_metadata.c

-// RUN: %clang_cc1 -fopenmp=libiomp5 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fopenmp=libiomp5 -triple x86_64-unknown-unknown -emit-llvm %s -o - | FileCheck %s
 
-void h1(float *c, float *a, float *b, int size)
+void h1(float *c, float *a, double b[], int size)
 {
 // CHECK-LABEL: define void @h1
   int t = 0;
-#pragma omp simd safelen(16) linear(t)
+#pragma omp simd safelen(16) linear(t) aligned(c:32) aligned(a,b)
+// CHECK:         [[C_PTRINT:%.+]] = ptrtoint
+// CHECK-NEXT:    [[C_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[C_PTRINT]], 31
+// CHECK-NEXT:    [[C_MASKCOND:%.+]] = icmp eq i{{[0-9]+}} [[C_MASKEDPTR]], 0
+// CHECK-NEXT:    call void @llvm.assume(i1 [[C_MASKCOND]])
+// CHECK:         [[A_PTRINT:%.+]] = ptrtoint
+// CHECK-NEXT:    [[A_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[A_PTRINT]], 15
+// CHECK-NEXT:    [[A_MASKCOND:%.+]] = icmp eq i{{[0-9]+}} [[A_MASKEDPTR]], 0
+// CHECK-NEXT:    call void @llvm.assume(i1 [[A_MASKCOND]])
+// CHECK:         [[B_PTRINT:%.+]] = ptrtoint
+// CHECK-NEXT:    [[B_MASKEDPTR:%.+]] = and i{{[0-9]+}} [[B_PTRINT]], 15
+// CHECK-NEXT:    [[B_MASKCOND:%.+]] = icmp eq i{{[0-9]+}} [[B_MASKEDPTR]], 0
+// CHECK-NEXT:    call void @llvm.assume(i1 [[B_MASKCOND]])
   for (int i = 0; i < size; ++i) {
     c[i] = a[i] * a[i] + b[i] * b[t];
     ++t;
 // do not emit parallel_loop_access metadata due to usage of safelen clause.
 // CHECK-NOT: store float {{.+}}, float* {{.+}}, align {{.+}}, !llvm.mem.parallel_loop_access {{![0-9]+}}
   }
 }