[Clang][OpenMP] Add the codegen support for `atomic compare capture`

[tianshilei1992]

Summary

This patch adds the codegen support for atomic compare capture in clang.

[tianshilei1992]

add tests

[ABataev]

clang/include/clang/AST/StmtOpenMP.h

2829–2855

Transform these booleans to bitfields?

clang/lib/Sema/SemaOpenMP.cpp

11852

Need to be careful here, probably may need to cast to resulting type explicitly to avoid problems between int/float/etc. conversions.

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11852

I think we don't need that as D and E are supposed to be rvalue, and as shown here I only ignore implicit casts for rvalue.

[tianshilei1992]

clang/include/clang/AST/StmtOpenMP.h

2829–2855

Will do in another patch.

[nikic]

clang/lib/CodeGen/CGStmtOpenMP.cpp

6205

Please avoid adding new calls to getPointerElementType(). See https://github.com/llvm/llvm-project/commit/b1863d82454b2905db8b492bea0ce8a260362645 for a way to avoid it in this context.

[tianshilei1992]

rebase and fix comments

[tianshilei1992]

clang/lib/CodeGen/CGStmtOpenMP.cpp

6205

Got it. Thanks for the info.

[tianshilei1992]

rebase

[ABataev]

clang/include/clang/AST/StmtOpenMP.h

2935–2942

There are too many params already, better to gather them into a struct/class

clang/lib/CodeGen/CGStmtOpenMP.cpp

6358

Can this be fixed in a separate patch?

[tianshilei1992]

clang/include/clang/AST/StmtOpenMP.h

2935–2942

Sure, we could do that.

clang/lib/CodeGen/CGStmtOpenMP.cpp

6358

Well, I think it's part of this patch because we can't tell if it's compare or compare capture before, but now we can. If we really want to do that, we can have another patch including all changes in this patch related to OMPAtomicDirective.

[ABataev]

clang/lib/CodeGen/CGStmtOpenMP.cpp

6358

Kind of NFC? Would be good

[tianshilei1992]

rebase

[tianshilei1992]

clang/include/clang/AST/StmtOpenMP.h

2829–2855

In D123862.

clang/lib/CodeGen/CGStmtOpenMP.cpp

6358

I think we don't need an extra NFC patch for this part because it's not gonna be very neat w/o some other code in this patch.

[tianshilei1992]

rebase

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11719

Why do we need to use IgnoreImpCasts() here and in other places?

[tianshilei1992]

clang/lib/Sema/SemaOpenMP.cpp

11719

Clang usually inserts implicit casts. For example, if we have:

char a, b, c;
#pragma omp atomic compare capture
  { r = a; if (a > c) { a = b; } }

Clang inserts an implicit cast from char to int for all statements except r = a. In this case, what should be the right solution? I'm not quite sure actually.

[tianshilei1992]

ping

clang/lib/Sema/SemaOpenMP.cpp

11719

https://godbolt.org/z/a6WWdx581
This shows how the AST looks like.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

11719

I don't see casts to int in a=b (BO points to this expression,right?). The only cast, that maybe should be removed here, is LValueToRValue

[tianshilei1992]

fix comments

[ABataev]

clang/lib/CodeGen/CGStmtOpenMP.cpp

6189

1. auto *CI
2. What if this is not a constant, but just a value with int type? Is this possible?

clang/lib/Sema/SemaOpenMP.cpp

11852

Same question as before. It is assignment BO, do you really need to remove casts here?

11866

Maybe, IgnoreImplicitAsWritten?

[tianshilei1992]

clang/lib/CodeGen/CGStmtOpenMP.cpp

6189

What if this is not a constant, but just a value with int type? Is this possible?

I'm thinking of a similar case.

void foo() {
  int e, d;
  char x, v;
  if (x == e)
    x = d;
}

In this case, there are two casts:

1. In expression x == e, cast x to int.
2. In expression x = d, cast d to char.

We cannot ignore both of them. For the 2nd, no question. For the expression x == e, the problem is in e instead of x. e here is always int, further causing issue in codegen.

I'm thinking for those lvalues, we can only set them where they are used as lvalues in case any type lifting. For those rvalues, if their types are not same as x, but compatible with x, we have to insert cast, including truncate, before feed them into codegen. Does it sound good?

[tianshilei1992]

rebase

[tianshilei1992]

fix the wrong use of AtomicOpValue

[tianshilei1992]

ping

[ABataev]

LG

[tianshilei1992]

rebase

clang/include/clang/AST/StmtOpenMP.h

 ///
 /// \code
 /// #pragma omp atomic capture
 /// \endcode
 /// In this example directive '#pragma omp atomic' has clause 'capture'.
 ///
 class OMPAtomicDirective : public OMPExecutableDirective {
   friend class ASTStmtReader;
   friend class OMPExecutableDirective;
 
   struct FlagTy {
     /// Used for 'atomic update' or 'atomic capture' constructs. They may
     /// have atomic expressions of forms:
     /// \code
     /// x = x binop expr;
     /// x = expr binop x;
     /// \endcode
     /// This field is 1 for the first form of the expression and 0 for the
     /// second. Required for correct codegen of non-associative operations (like
     /// << or >>).
     uint8_t IsXLHSInRHSPart : 1;
     /// Used for 'atomic update' or 'atomic capture' constructs. They may
     /// have atomic expressions of forms:
     /// \code
     /// v = x; <update x>;
     /// <update x>; v = x;
     /// \endcode
     /// This field is 1 for the first(postfix) form of the expression and 0
     /// otherwise.
     uint8_t IsPostfixUpdate : 1;
+    /// 1 if 'v' is updated only when the condition is false (compare capture
+    /// only).
+    uint8_t IsFailOnly : 1;
   } Flags;
 
   /// Build directive with the given start and end location.
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
   ///
   OMPAtomicDirective(SourceLocation StartLoc, SourceLocation EndLoc)
       : OMPExecutableDirective(OMPAtomicDirectiveClass, llvm::omp::OMPD_atomic,
                                StartLoc, EndLoc) {}
 
   /// Build an empty directive.
   ///
   explicit OMPAtomicDirective()
       : OMPExecutableDirective(OMPAtomicDirectiveClass, llvm::omp::OMPD_atomic,
                                SourceLocation(), SourceLocation()) {}
 
   enum DataPositionTy : size_t {
     POS_X = 0,
     POS_V,
     POS_E,
     POS_UpdateExpr,
     POS_D,
     POS_Cond,
+    POS_R,
   };
 
   /// Set 'x' part of the associated expression/statement.
   void setX(Expr *X) { Data->getChildren()[DataPositionTy::POS_X] = X; }
   /// Set helper expression of the form
   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
   void setUpdateExpr(Expr *UE) {
     Data->getChildren()[DataPositionTy::POS_UpdateExpr] = UE;
   }
   /// Set 'v' part of the associated expression/statement.
   void setV(Expr *V) { Data->getChildren()[DataPositionTy::POS_V] = V; }
+  /// Set 'r' part of the associated expression/statement.
+  void setR(Expr *R) { Data->getChildren()[DataPositionTy::POS_R] = R; }
   /// Set 'expr' part of the associated expression/statement.
   void setExpr(Expr *E) { Data->getChildren()[DataPositionTy::POS_E] = E; }
   /// Set 'd' part of the associated expression/statement.
   void setD(Expr *D) { Data->getChildren()[DataPositionTy::POS_D] = D; }
   /// Set conditional expression in `atomic compare`.
   void setCond(Expr *C) { Data->getChildren()[DataPositionTy::POS_Cond] = C; }
 
 public:
   struct Expressions {
     /// 'x' part of the associated expression/statement.
     Expr *X = nullptr;
     /// 'v' part of the associated expression/statement.
     Expr *V = nullptr;
+    // 'r' part of the associated expression/statement.
+    Expr *R = nullptr;
     /// 'expr' part of the associated expression/statement.
     Expr *E = nullptr;
     /// UE Helper expression of the form:
     /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or
     /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
     Expr *UE = nullptr;
     /// 'd' part of the associated expression/statement.
     Expr *D = nullptr;
     /// Conditional expression in `atomic compare` construct.
     Expr *Cond = nullptr;
     /// True if UE has the first form and false if the second.
     bool IsXLHSInRHSPart;
     /// True if original value of 'x' must be stored in 'v', not an updated one.
     bool IsPostfixUpdate;
+    /// True if 'v' is updated only when the condition is false (compare capture
+    /// only).
+    bool IsFailOnly;
   };
 
   /// Creates directive with a list of \a Clauses and 'x', 'v' and 'expr'
   /// parts of the atomic construct (see Section 2.12.6, atomic Construct, for
   /// detailed description of 'x', 'v' and 'expr').
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
   /// \param Clauses List of clauses.
   /// \param AssociatedStmt Statement, associated with the directive.
   /// \param Exprs Associated expressions or statements.
   static OMPAtomicDirective *Create(const ASTContext &C,
                                     SourceLocation StartLoc,
                                     SourceLocation EndLoc,
                                     ArrayRef<OMPClause *> Clauses,
                                     Stmt *AssociatedStmt, Expressions Exprs);
 
   /// Creates an empty directive with the place for \a NumClauses
   /// clauses.
   ///
   /// \param C AST context.
   /// \param NumClauses Number of clauses.
   ///
   static OMPAtomicDirective *CreateEmpty(const ASTContext &C,
                                          unsigned NumClauses, EmptyShell);
public:
   }
   /// Return true if helper update expression has form
   /// 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' and false if it has form
   /// 'OpaqueValueExpr(expr) binop OpaqueValueExpr(x)'.
   bool isXLHSInRHSPart() const { return Flags.IsXLHSInRHSPart; }
   /// Return true if 'v' expression must be updated to original value of
   /// 'x', false if 'v' must be updated to the new value of 'x'.
   bool isPostfixUpdate() const { return Flags.IsPostfixUpdate; }
+  /// Return true if 'v' is updated only when the condition is evaluated false
+  /// (compare capture only).
+  bool isFailOnly() const { return Flags.IsFailOnly; }
   /// Get 'v' part of the associated expression/statement.
   Expr *getV() {
     return cast_or_null<Expr>(Data->getChildren()[DataPositionTy::POS_V]);
   }
   const Expr *getV() const {
     return cast_or_null<Expr>(Data->getChildren()[DataPositionTy::POS_V]);
   }
+  /// Get 'r' part of the associated expression/statement.
+  Expr *getR() {
+    return cast_or_null<Expr>(Data->getChildren()[DataPositionTy::POS_R]);
+  }
+  const Expr *getR() const {
+    return cast_or_null<Expr>(Data->getChildren()[DataPositionTy::POS_R]);
+  }
   /// Get 'expr' part of the associated expression/statement.
   Expr *getExpr() {
     return cast_or_null<Expr>(Data->getChildren()[DataPositionTy::POS_E]);
   }
   const Expr *getExpr() const {
     return cast_or_null<Expr>(Data->getChildren()[DataPositionTy::POS_E]);
   }
   /// Get 'd' part of the associated expression/statement.

clang/lib/AST/StmtOpenMP.cpp

return createEmptyDirective<OMPOrderedDirective>(C, NumClauses,
                                                    !IsStandalone);
 }
 
 OMPAtomicDirective *
 OMPAtomicDirective::Create(const ASTContext &C, SourceLocation StartLoc,
                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                            Stmt *AssociatedStmt, Expressions Exprs) {
   auto *Dir = createDirective<OMPAtomicDirective>(
-      C, Clauses, AssociatedStmt, /*NumChildren=*/6, StartLoc, EndLoc);
+      C, Clauses, AssociatedStmt, /*NumChildren=*/7, StartLoc, EndLoc);
   Dir->setX(Exprs.X);
   Dir->setV(Exprs.V);
+  Dir->setR(Exprs.R);
   Dir->setExpr(Exprs.E);
   Dir->setUpdateExpr(Exprs.UE);
   Dir->setD(Exprs.D);
   Dir->setCond(Exprs.Cond);
   Dir->Flags.IsXLHSInRHSPart = Exprs.IsXLHSInRHSPart ? 1 : 0;
   Dir->Flags.IsPostfixUpdate = Exprs.IsPostfixUpdate ? 1 : 0;
+  Dir->Flags.IsFailOnly = Exprs.IsFailOnly ? 1 : 0;
   return Dir;
 }
 
 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPAtomicDirective>(
-      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/6);
+      C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/7);
 }
 
 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
                                                Stmt *AssociatedStmt) {
   return createDirective<OMPTargetDirective>(

clang/lib/CodeGen/CGStmtOpenMP.cpp

if (CGF.CGM.getLangOpts().OpenMP < 51) {
     case llvm::AtomicOrdering::Unordered:
       llvm_unreachable("Unexpected ordering.");
     }
   }
 }
 
 static void emitOMPAtomicCompareExpr(CodeGenFunction &CGF,
                                      llvm::AtomicOrdering AO, const Expr *X,
+                                     const Expr *V, const Expr *R,
                                      const Expr *E, const Expr *D,
                                      const Expr *CE, bool IsXBinopExpr,
+                                     bool IsPostfixUpdate, bool IsFailOnly,
                                      SourceLocation Loc) {
   llvm::OpenMPIRBuilder &OMPBuilder =
       CGF.CGM.getOpenMPRuntime().getOMPBuilder();
 
   OMPAtomicCompareOp Op;
   assert(isa<BinaryOperator>(CE) && "CE is not a BinaryOperator");
   switch (cast<BinaryOperator>(CE)->getOpcode()) {
   case BO_EQ:
     Op = OMPAtomicCompareOp::EQ;
     break;
   case BO_LT:
     Op = OMPAtomicCompareOp::MIN;
     break;
   case BO_GT:
     Op = OMPAtomicCompareOp::MAX;
     break;
   default:
     llvm_unreachable("unsupported atomic compare binary operator");
   }
 
   LValue XLVal = CGF.EmitLValue(X);
   Address XAddr = XLVal.getAddress(CGF);
   llvm::Value *EVal = CGF.EmitScalarExpr(E);
+  if (auto *CI = dyn_cast<llvm::ConstantInt>(EVal))
+    EVal = CGF.Builder.CreateIntCast(
+        CI, XLVal.getAddress(CGF).getElementType(),
+        E->getType()->hasSignedIntegerRepresentation());
   llvm::Value *DVal = D ? CGF.EmitScalarExpr(D) : nullptr;
-
+  if (DVal)
+    if (auto *CI = dyn_cast<llvm::ConstantInt>(DVal))
+      DVal = CGF.Builder.CreateIntCast(
+          CI, XLVal.getAddress(CGF).getElementType(),
+          D->getType()->hasSignedIntegerRepresentation());
   llvm::OpenMPIRBuilder::AtomicOpValue XOpVal{
       XAddr.getPointer(), XAddr.getElementType(),
       X->getType().isVolatileQualified(),
       X->getType()->hasSignedIntegerRepresentation()};
+  llvm::OpenMPIRBuilder::AtomicOpValue VOpVal;
+  if (V) {
+    LValue LV = CGF.EmitLValue(V);
+    Address Addr = LV.getAddress(CGF);
+    VOpVal = {Addr.getPointer(), Addr.getElementType(),
+              V->getType().isVolatileQualified(),
+              V->getType()->hasSignedIntegerRepresentation()};
+  }
+  llvm::OpenMPIRBuilder::AtomicOpValue ROpVal;
+  if (R) {
+    LValue LV = CGF.EmitLValue(R);
+    Address Addr = LV.getAddress(CGF);
+    ROpVal = {Addr.getPointer(), Addr.getElementType(),
+              R->getType().isVolatileQualified(),
+              R->getType()->hasSignedIntegerRepresentation()};
+  }
 
   CGF.Builder.restoreIP(OMPBuilder.createAtomicCompare(
-      CGF.Builder, XOpVal, EVal, DVal, AO, Op, IsXBinopExpr));
+      CGF.Builder, XOpVal, VOpVal, ROpVal, EVal, DVal, AO, Op, IsXBinopExpr,
+      IsPostfixUpdate, IsFailOnly));
 }
 
 static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
                               llvm::AtomicOrdering AO, bool IsPostfixUpdate,
-                              const Expr *X, const Expr *V, const Expr *E,
-                              const Expr *UE, const Expr *D, const Expr *CE,
-                              bool IsXLHSInRHSPart, bool IsCompareCapture,
-                              SourceLocation Loc) {
+                              const Expr *X, const Expr *V, const Expr *R,
+                              const Expr *E, const Expr *UE, const Expr *D,
+                              const Expr *CE, bool IsXLHSInRHSPart,
+                              bool IsFailOnly, SourceLocation Loc) {
   switch (Kind) {
   case OMPC_read:
     emitOMPAtomicReadExpr(CGF, AO, X, V, Loc);
     break;
   case OMPC_write:
     emitOMPAtomicWriteExpr(CGF, AO, X, E, Loc);
     break;
   case OMPC_unknown:
   case OMPC_update:
     emitOMPAtomicUpdateExpr(CGF, AO, X, E, UE, IsXLHSInRHSPart, Loc);
     break;
   case OMPC_capture:
     emitOMPAtomicCaptureExpr(CGF, AO, IsPostfixUpdate, V, X, E, UE,
                              IsXLHSInRHSPart, Loc);
     break;
   case OMPC_compare: {
-    if (IsCompareCapture) {
-      // Emit an error here.
-      unsigned DiagID = CGF.CGM.getDiags().getCustomDiagID(
-          DiagnosticsEngine::Error,
-          "'atomic compare capture' is not supported for now");
-      CGF.CGM.getDiags().Report(DiagID);
-    } else {
-      emitOMPAtomicCompareExpr(CGF, AO, X, E, D, CE, IsXLHSInRHSPart, Loc);
-    }
+    emitOMPAtomicCompareExpr(CGF, AO, X, V, R, E, D, CE, IsXLHSInRHSPart,
+                             IsPostfixUpdate, IsFailOnly, Loc);
     break;
   }
   case OMPC_if:
   case OMPC_final:
   case OMPC_num_threads:
   case OMPC_private:
   case OMPC_firstprivate:
   case OMPC_lastprivate:
for (const OMPClause *C : S.clauses()) {
     // if it is first).
     OpenMPClauseKind K = C->getClauseKind();
     if (K == OMPC_seq_cst || K == OMPC_acq_rel || K == OMPC_acquire ||
         K == OMPC_release || K == OMPC_relaxed || K == OMPC_hint)
       continue;
     Kind = K;
     KindsEncountered.insert(K);
   }
-  bool IsCompareCapture = false;
+  // We just need to correct Kind here. No need to set a bool saying it is
+  // actually compare capture because we can tell from whether V and R are
+  // nullptr.
   if (KindsEncountered.contains(OMPC_compare) &&
-      KindsEncountered.contains(OMPC_capture)) {
-    IsCompareCapture = true;
+      KindsEncountered.contains(OMPC_capture))
     Kind = OMPC_compare;
-  }
   if (!MemOrderingSpecified) {
     llvm::AtomicOrdering DefaultOrder =
         CGM.getOpenMPRuntime().getDefaultMemoryOrdering();
     if (DefaultOrder == llvm::AtomicOrdering::Monotonic ||
         DefaultOrder == llvm::AtomicOrdering::SequentiallyConsistent ||
         (DefaultOrder == llvm::AtomicOrdering::AcquireRelease &&
          Kind == OMPC_capture)) {
       AO = DefaultOrder;
     } else if (DefaultOrder == llvm::AtomicOrdering::AcquireRelease) {
       if (Kind == OMPC_unknown || Kind == OMPC_update || Kind == OMPC_write) {
         AO = llvm::AtomicOrdering::Release;
       } else if (Kind == OMPC_read) {
         assert(Kind == OMPC_read && "Unexpected atomic kind.");
         AO = llvm::AtomicOrdering::Acquire;
       }
     }
   }
 
   LexicalScope Scope(*this, S.getSourceRange());
   EmitStopPoint(S.getAssociatedStmt());
   emitOMPAtomicExpr(*this, Kind, AO, S.isPostfixUpdate(), S.getX(), S.getV(),
-                    S.getExpr(), S.getUpdateExpr(), S.getD(), S.getCondExpr(),
-                    S.isXLHSInRHSPart(), IsCompareCapture, S.getBeginLoc());
+                    S.getR(), S.getExpr(), S.getUpdateExpr(), S.getD(),
+                    S.getCondExpr(), S.isXLHSInRHSPart(), S.isFailOnly(),
+                    S.getBeginLoc());
 }
 
 static void emitCommonOMPTargetDirective(CodeGenFunction &CGF,
                                          const OMPExecutableDirective &S,
                                          const RegionCodeGenTy &CodeGen) {
   assert(isOpenMPTargetExecutionDirective(S.getDirectiveKind()));
   CodeGenModule &CGM = CGF.CGM;
 

clang/lib/Sema/SemaOpenMP.cpp

 class OpenMPAtomicCompareCaptureChecker final
     : public OpenMPAtomicCompareChecker {
 public:
   OpenMPAtomicCompareCaptureChecker(Sema &S) : OpenMPAtomicCompareChecker(S) {}
 
   Expr *getV() const { return V; }
   Expr *getR() const { return R; }
   bool isFailOnly() const { return IsFailOnly; }
+  bool isPostfixUpdate() const { return IsPostfixUpdate; }
 
   /// Check if statement \a S is valid for <tt>atomic compare capture</tt>.
   bool checkStmt(Stmt *S, ErrorInfoTy &ErrorInfo);
 
 private:
   bool checkType(ErrorInfoTy &ErrorInfo);
 
   // NOTE: Form 3, 4, 5 in the following comments mean the 3rd, 4th, and 5th
private:
   bool checkForm45(Stmt *S, ErrorInfoTy &ErrorInfo);
 
   /// 'v' lvalue part of the source atomic expression.
   Expr *V = nullptr;
   /// 'r' lvalue part of the source atomic expression.
   Expr *R = nullptr;
   /// If 'v' is only updated when the comparison fails.
   bool IsFailOnly = false;
+  /// If original value of 'x' must be stored in 'v', not an updated one.
+  bool IsPostfixUpdate = false;
 };
 
 bool OpenMPAtomicCompareCaptureChecker::checkType(ErrorInfoTy &ErrorInfo) {
   if (!OpenMPAtomicCompareChecker::checkType(ErrorInfo))
     return false;
 
   if (V && !CheckValue(V, ErrorInfo, true))
     return false;
if (BO->getOpcode() != BO_Assign) {
     ErrorInfo.Error = ErrorTy::NotAnAssignment;
     ErrorInfo.ErrorLoc = BO->getExprLoc();
     ErrorInfo.NoteLoc = BO->getOperatorLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = BO->getSourceRange();
     return false;
   }
 
   X = BO->getLHS();
   D = BO->getRHS();
 
   auto *Cond = dyn_cast<BinaryOperator>(S->getCond());
   if (!Cond) {
     ErrorInfo.Error = ErrorTy::NotABinaryOp;
     ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = S->getCond()->getExprLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = S->getCond()->getSourceRange();
     return false;
   }
   if (Cond->getOpcode() != BO_EQ) {
     ErrorInfo.Error = ErrorTy::NotEQ;
     ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
     return false;
   }
 
   if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getLHS())) {
-    E = Cond->getRHS();
+    E = Cond->getRHS()->IgnoreImplicitAsWritten();
   } else if (checkIfTwoExprsAreSame(ContextRef, X, Cond->getRHS())) {
-    E = Cond->getLHS();
+    E = Cond->getLHS()->IgnoreImplicitAsWritten();
   } else {
     ErrorInfo.Error = ErrorTy::InvalidComparison;
     ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = Cond->getExprLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = Cond->getSourceRange();
     return false;
   }
 
   C = Cond;
if (ThenBO->getOpcode() != BO_Assign) {
     ErrorInfo.Error = ErrorTy::NotAnAssignment;
     ErrorInfo.ErrorLoc = ThenBO->getExprLoc();
     ErrorInfo.NoteLoc = ThenBO->getOperatorLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = ThenBO->getSourceRange();
     return false;
   }
 
   X = ThenBO->getLHS();
-  D = ThenBO->getRHS();
+  D = ThenBO->getRHS()->IgnoreImplicitAsWritten();
 
   auto *BO = cast<BinaryOperator>(S1->getRHS()->IgnoreImpCasts());
   if (BO->getOpcode() != BO_EQ) {
     ErrorInfo.Error = ErrorTy::NotEQ;
     ErrorInfo.ErrorLoc = BO->getExprLoc();
     ErrorInfo.NoteLoc = BO->getOperatorLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = BO->getSourceRange();
     return false;
   }
 
   C = BO;
 
   if (checkIfTwoExprsAreSame(ContextRef, X, BO->getLHS())) {
-    E = BO->getRHS();
+    E = BO->getRHS()->IgnoreImplicitAsWritten();
   } else if (checkIfTwoExprsAreSame(ContextRef, X, BO->getRHS())) {
-    E = BO->getLHS();
+    E = BO->getLHS()->IgnoreImplicitAsWritten();
   } else {
     ErrorInfo.Error = ErrorTy::InvalidComparison;
     ErrorInfo.ErrorLoc = ErrorInfo.NoteLoc = BO->getExprLoc();
     ErrorInfo.ErrorRange = ErrorInfo.NoteRange = BO->getSourceRange();
     return false;
   }
 
   if (S2->getElse()) {
if (CS->size() == 1) {
     if (auto *BO = dyn_cast<BinaryOperator>(S1)) {
       // { v = x; cond-update-stmt } or form 45.
       UpdateStmt = S1;
       CondUpdateStmt = S2;
       // Check if form 45.
       if (dyn_cast<BinaryOperator>(BO->getRHS()->IgnoreImpCasts()) &&
           dyn_cast<IfStmt>(S2))
         return checkForm45(CS, ErrorInfo);
+      // It cannot be set before we the check for form45.
+      IsPostfixUpdate = true;
     } else {
       // { cond-update-stmt v = x; }
       UpdateStmt = S2;
       CondUpdateStmt = S1;
     }
 
     auto CheckCondUpdateStmt = [this, &ErrorInfo](Stmt *CUS) {
       auto *IS = dyn_cast<IfStmt>(CUS);
if (auto *EWC = dyn_cast<ExprWithCleanups>(Body))
     Body = EWC->getSubExpr();
 
   Expr *X = nullptr;
   Expr *V = nullptr;
   Expr *E = nullptr;
   Expr *UE = nullptr;
   Expr *D = nullptr;
   Expr *CE = nullptr;
+  Expr *R = nullptr;
   bool IsXLHSInRHSPart = false;
   bool IsPostfixUpdate = false;
+  bool IsFailOnly = false;
   // OpenMP [2.12.6, atomic Construct]
   // In the next expressions:
   // * x and v (as applicable) are both l-value expressions with scalar type.
   // * During the execution of an atomic region, multiple syntactic
   // occurrences of x must designate the same storage location.
   // * Neither of v and expr (as applicable) may access the storage location
   // designated by x.
   // * Neither of x and expr (as applicable) may access the storage location
if (IsCompareCapture) {
       OpenMPAtomicCompareCaptureChecker Checker(*this);
       if (!Checker.checkStmt(Body, ErrorInfo)) {
         Diag(ErrorInfo.ErrorLoc, diag::err_omp_atomic_compare_capture)
             << ErrorInfo.ErrorRange;
         Diag(ErrorInfo.NoteLoc, diag::note_omp_atomic_compare)
             << ErrorInfo.Error << ErrorInfo.NoteRange;
         return StmtError();
       }
-      // TODO: We don't set X, D, E, etc. here because in code gen we will emit
-      // error directly.
+      X = Checker.getX();
+      E = Checker.getE();
+      D = Checker.getD();
+      CE = Checker.getCond();
+      V = Checker.getV();
+      R = Checker.getR();
+      // We reuse IsXLHSInRHSPart to tell if it is in the form 'x ordop expr'.
+      IsXLHSInRHSPart = Checker.isXBinopExpr();
+      IsFailOnly = Checker.isFailOnly();
+      IsPostfixUpdate = Checker.isPostfixUpdate();
     } else {
       OpenMPAtomicCompareChecker::ErrorInfoTy ErrorInfo;
       OpenMPAtomicCompareChecker Checker(*this);
       if (!Checker.checkStmt(Body, ErrorInfo)) {
         Diag(ErrorInfo.ErrorLoc, diag::err_omp_atomic_compare)
             << ErrorInfo.ErrorRange;
         Diag(ErrorInfo.NoteLoc, diag::note_omp_atomic_compare)
-            << ErrorInfo.Error << ErrorInfo.NoteRange;
         return StmtError();
       }
       X = Checker.getX();
       E = Checker.getE();
       D = Checker.getD();
       CE = Checker.getCond();
       // We reuse IsXLHSInRHSPart to tell if it is in the form 'x ordop expr'.
       IsXLHSInRHSPart = Checker.isXBinopExpr();
     }
   }
 
   setFunctionHasBranchProtectedScope();
 
   return OMPAtomicDirective::Create(
       Context, StartLoc, EndLoc, Clauses, AStmt,
-      {X, V, E, UE, D, CE, IsXLHSInRHSPart, IsPostfixUpdate});
+      {X, V, R, E, UE, D, CE, IsXLHSInRHSPart, IsPostfixUpdate, IsFailOnly});
 }
 
 StmtResult Sema::ActOnOpenMPTargetDirective(ArrayRef<OMPClause *> Clauses,
                                             Stmt *AStmt,
                                             SourceLocation StartLoc,
                                             SourceLocation EndLoc) {
   if (!AStmt)
     return StmtError();

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0;
   D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0;
+  D->Flags.IsFailOnly = Record.readBool() ? 1 : 0;
 }
 
 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
   Code = serialization::STMT_OMP_TASK_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Record.writeBool(D->isXLHSInRHSPart());
   Record.writeBool(D->isPostfixUpdate());
+  Record.writeBool(D->isFailOnly());
   Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_TARGET_DIRECTIVE;
 }

clang/test/OpenMP/atomic_compare_codegen.cpp

 #pragma omp atomic compare seq_cst
   if (ullx == ulle)
     ullx = ulld;
 #pragma omp atomic compare seq_cst
   if (ulle == ullx)
     ullx = ulld;
 }
 
+void bar() {
+  char cx, cv, cr, ce, cd;
+  unsigned char ucx, ucv, ucr, uce, ucd;
+  short sx, sv, sr, se, sd;
+  unsigned short usx, usv, usr, use, usd;
+  int ix, iv, ir, ie, id;
+  unsigned int uix, uiv, uir, uie, uid;
+  long lx, lv, lr, le, ld;
+  unsigned long ulx, ulv, ulr, ule, uld;
+  long long llx, llv, llr, lle, lld;
+  unsigned long long ullx, ullv, ullr, ulle, ulld;
+
+#pragma omp atomic compare capture
+  {
+    cv = cx;
+    if (ce > cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cv = cx;
+    if (cx > ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cv = cx;
+    if (ce < cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cv = cx;
+    if (cx < ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cv = cx;
+    if (cx == ce) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cv = cx;
+    if (ce == cx) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (ce > cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (cx > ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ce < cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (cx < ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (cx == ce) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ce == cx) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  if (cx == ce) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  if (ce == cx) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    cv = cx;
+    if (ce > cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cv = cx;
+    if (cx > ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cv = cx;
+    if (ce < cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cv = cx;
+    if (cx < ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cv = cx;
+    if (cx == ce) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cv = cx;
+    if (ce == cx) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ce > cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (cx > ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ce < cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (cx < ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (cx == ce) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ce == cx) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (cx == ce) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ce == cx) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    cv = cx;
+    if (ce > cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cv = cx;
+    if (cx > ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cv = cx;
+    if (ce < cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cv = cx;
+    if (cx < ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cv = cx;
+    if (cx == ce) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cv = cx;
+    if (ce == cx) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ce > cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (cx > ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ce < cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (cx < ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (cx == ce) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ce == cx) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  if (cx == ce) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  if (ce == cx) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    cv = cx;
+    if (ce > cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cv = cx;
+    if (cx > ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cv = cx;
+    if (ce < cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cv = cx;
+    if (cx < ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cv = cx;
+    if (cx == ce) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cv = cx;
+    if (ce == cx) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ce > cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (cx > ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ce < cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (cx < ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (cx == ce) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ce == cx) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (cx == ce) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ce == cx) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    cv = cx;
+    if (ce > cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cv = cx;
+    if (cx > ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cv = cx;
+    if (ce < cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cv = cx;
+    if (cx < ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cv = cx;
+    if (cx == ce) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cv = cx;
+    if (ce == cx) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ce > cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (cx > ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ce < cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (cx < ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (cx == ce) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ce == cx) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  if (cx == ce) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  if (ce == cx) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture release
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    cv = cx;
+    if (ce > cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cv = cx;
+    if (cx > ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cv = cx;
+    if (ce < cx) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cv = cx;
+    if (cx < ce) {
+      cx = ce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cv = cx;
+    if (cx == ce) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cv = cx;
+    if (ce == cx) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ce > cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (cx > ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ce < cx) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (cx < ce) {
+      cx = ce;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (cx == ce) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ce == cx) {
+      cx = cd;
+    }
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (cx == ce) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ce == cx) {
+    cx = cd;
+  } else {
+    cv = cx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cr = cx == ce;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    cr = ce == cx;
+    if (cr) {
+      cx = cd;
+    } else {
+      cv = cx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    ucv = ucx;
+    if (uce > ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucv = ucx;
+    if (ucx > uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucv = ucx;
+    if (uce < ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucv = ucx;
+    if (ucx < uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucv = ucx;
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucv = ucx;
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (uce > ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ucx > uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uce < ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ucx < uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  if (ucx == uce) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  if (uce == ucx) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    ucv = ucx;
+    if (uce > ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucv = ucx;
+    if (ucx > uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucv = ucx;
+    if (uce < ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucv = ucx;
+    if (ucx < uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucv = ucx;
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucv = ucx;
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uce > ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ucx > uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uce < ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ucx < uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ucx == uce) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (uce == ucx) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    ucv = ucx;
+    if (uce > ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucv = ucx;
+    if (ucx > uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucv = ucx;
+    if (uce < ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucv = ucx;
+    if (ucx < uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucv = ucx;
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucv = ucx;
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uce > ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ucx > uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uce < ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ucx < uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  if (ucx == uce) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  if (uce == ucx) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    ucv = ucx;
+    if (uce > ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucv = ucx;
+    if (ucx > uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucv = ucx;
+    if (uce < ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucv = ucx;
+    if (ucx < uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucv = ucx;
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucv = ucx;
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uce > ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ucx > uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uce < ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ucx < uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ucx == uce) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (uce == ucx) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    ucv = ucx;
+    if (uce > ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucv = ucx;
+    if (ucx > uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucv = ucx;
+    if (uce < ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucv = ucx;
+    if (ucx < uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucv = ucx;
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucv = ucx;
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uce > ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ucx > uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uce < ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ucx < uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  if (ucx == uce) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  if (uce == ucx) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture release
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    ucv = ucx;
+    if (uce > ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucv = ucx;
+    if (ucx > uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucv = ucx;
+    if (uce < ucx) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucv = ucx;
+    if (ucx < uce) {
+      ucx = uce;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucv = ucx;
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucv = ucx;
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uce > ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ucx > uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uce < ucx) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ucx < uce) {
+      ucx = uce;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ucx == uce) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uce == ucx) {
+      ucx = ucd;
+    }
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ucx == uce) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (uce == ucx) {
+    ucx = ucd;
+  } else {
+    ucv = ucx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucr = ucx == uce;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ucr = uce == ucx;
+    if (ucr) {
+      ucx = ucd;
+    } else {
+      ucv = ucx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    sv = sx;
+    if (se > sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sv = sx;
+    if (sx > se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sv = sx;
+    if (se < sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sv = sx;
+    if (sx < se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sv = sx;
+    if (sx == se) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sv = sx;
+    if (se == sx) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (se > sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (sx > se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (se < sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (sx < se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (sx == se) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (se == sx) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  if (sx == se) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  if (se == sx) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    sv = sx;
+    if (se > sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sv = sx;
+    if (sx > se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sv = sx;
+    if (se < sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sv = sx;
+    if (sx < se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sv = sx;
+    if (sx == se) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sv = sx;
+    if (se == sx) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (se > sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (sx > se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (se < sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (sx < se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (sx == se) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (se == sx) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (sx == se) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (se == sx) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    sv = sx;
+    if (se > sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sv = sx;
+    if (sx > se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sv = sx;
+    if (se < sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sv = sx;
+    if (sx < se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sv = sx;
+    if (sx == se) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sv = sx;
+    if (se == sx) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (se > sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (sx > se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (se < sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (sx < se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (sx == se) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (se == sx) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  if (sx == se) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  if (se == sx) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    sv = sx;
+    if (se > sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sv = sx;
+    if (sx > se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sv = sx;
+    if (se < sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sv = sx;
+    if (sx < se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sv = sx;
+    if (sx == se) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sv = sx;
+    if (se == sx) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (se > sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (sx > se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (se < sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (sx < se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (sx == se) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (se == sx) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (sx == se) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (se == sx) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    sv = sx;
+    if (se > sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sv = sx;
+    if (sx > se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sv = sx;
+    if (se < sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sv = sx;
+    if (sx < se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sv = sx;
+    if (sx == se) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sv = sx;
+    if (se == sx) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (se > sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (sx > se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (se < sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (sx < se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (sx == se) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (se == sx) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  if (sx == se) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  if (se == sx) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture release
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    sv = sx;
+    if (se > sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sv = sx;
+    if (sx > se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sv = sx;
+    if (se < sx) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sv = sx;
+    if (sx < se) {
+      sx = se;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sv = sx;
+    if (sx == se) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sv = sx;
+    if (se == sx) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (se > sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (sx > se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (se < sx) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (sx < se) {
+      sx = se;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (sx == se) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (se == sx) {
+      sx = sd;
+    }
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (sx == se) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (se == sx) {
+    sx = sd;
+  } else {
+    sv = sx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sr = sx == se;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    sr = se == sx;
+    if (sr) {
+      sx = sd;
+    } else {
+      sv = sx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    usv = usx;
+    if (use > usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usv = usx;
+    if (usx > use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usv = usx;
+    if (use < usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usv = usx;
+    if (usx < use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usv = usx;
+    if (usx == use) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usv = usx;
+    if (use == usx) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (use > usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (usx > use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (use < usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (usx < use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (usx == use) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (use == usx) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  if (usx == use) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  if (use == usx) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    usv = usx;
+    if (use > usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usv = usx;
+    if (usx > use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usv = usx;
+    if (use < usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usv = usx;
+    if (usx < use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usv = usx;
+    if (usx == use) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usv = usx;
+    if (use == usx) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (use > usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (usx > use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (use < usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (usx < use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (usx == use) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (use == usx) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (usx == use) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (use == usx) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    usv = usx;
+    if (use > usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usv = usx;
+    if (usx > use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usv = usx;
+    if (use < usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usv = usx;
+    if (usx < use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usv = usx;
+    if (usx == use) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usv = usx;
+    if (use == usx) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (use > usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (usx > use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (use < usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (usx < use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (usx == use) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (use == usx) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  if (usx == use) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  if (use == usx) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    usv = usx;
+    if (use > usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usv = usx;
+    if (usx > use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usv = usx;
+    if (use < usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usv = usx;
+    if (usx < use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usv = usx;
+    if (usx == use) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usv = usx;
+    if (use == usx) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (use > usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (usx > use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (use < usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (usx < use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (usx == use) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (use == usx) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (usx == use) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (use == usx) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    usv = usx;
+    if (use > usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usv = usx;
+    if (usx > use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usv = usx;
+    if (use < usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usv = usx;
+    if (usx < use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usv = usx;
+    if (usx == use) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usv = usx;
+    if (use == usx) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (use > usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (usx > use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (use < usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (usx < use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (usx == use) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (use == usx) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  if (usx == use) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  if (use == usx) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture release
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    usv = usx;
+    if (use > usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usv = usx;
+    if (usx > use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usv = usx;
+    if (use < usx) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usv = usx;
+    if (usx < use) {
+      usx = use;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usv = usx;
+    if (usx == use) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usv = usx;
+    if (use == usx) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (use > usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (usx > use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (use < usx) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (usx < use) {
+      usx = use;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (usx == use) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (use == usx) {
+      usx = usd;
+    }
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (usx == use) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (use == usx) {
+    usx = usd;
+  } else {
+    usv = usx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usr = usx == use;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    usr = use == usx;
+    if (usr) {
+      usx = usd;
+    } else {
+      usv = usx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    iv = ix;
+    if (ie > ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    iv = ix;
+    if (ix > ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    iv = ix;
+    if (ie < ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    iv = ix;
+    if (ix < ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    iv = ix;
+    if (ix == ie) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    iv = ix;
+    if (ie == ix) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (ie > ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ix > ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ie < ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ix < ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ix == ie) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ie == ix) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  if (ix == ie) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  if (ie == ix) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    iv = ix;
+    if (ie > ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    iv = ix;
+    if (ix > ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    iv = ix;
+    if (ie < ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    iv = ix;
+    if (ix < ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    iv = ix;
+    if (ix == ie) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    iv = ix;
+    if (ie == ix) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ie > ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ix > ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ie < ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ix < ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ix == ie) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ie == ix) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ix == ie) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ie == ix) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    iv = ix;
+    if (ie > ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    iv = ix;
+    if (ix > ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    iv = ix;
+    if (ie < ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    iv = ix;
+    if (ix < ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    iv = ix;
+    if (ix == ie) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    iv = ix;
+    if (ie == ix) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ie > ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ix > ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ie < ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ix < ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ix == ie) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ie == ix) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  if (ix == ie) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  if (ie == ix) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    iv = ix;
+    if (ie > ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    iv = ix;
+    if (ix > ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    iv = ix;
+    if (ie < ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    iv = ix;
+    if (ix < ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    iv = ix;
+    if (ix == ie) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    iv = ix;
+    if (ie == ix) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ie > ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ix > ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ie < ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ix < ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ix == ie) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ie == ix) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ix == ie) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ie == ix) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    iv = ix;
+    if (ie > ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    iv = ix;
+    if (ix > ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    iv = ix;
+    if (ie < ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    iv = ix;
+    if (ix < ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    iv = ix;
+    if (ix == ie) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    iv = ix;
+    if (ie == ix) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ie > ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ix > ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ie < ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ix < ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ix == ie) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ie == ix) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  if (ix == ie) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  if (ie == ix) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture release
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    iv = ix;
+    if (ie > ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    iv = ix;
+    if (ix > ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    iv = ix;
+    if (ie < ix) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    iv = ix;
+    if (ix < ie) {
+      ix = ie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    iv = ix;
+    if (ix == ie) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    iv = ix;
+    if (ie == ix) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ie > ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ix > ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ie < ix) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ix < ie) {
+      ix = ie;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ix == ie) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ie == ix) {
+      ix = id;
+    }
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ix == ie) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ie == ix) {
+    ix = id;
+  } else {
+    iv = ix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ir = ix == ie;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ir = ie == ix;
+    if (ir) {
+      ix = id;
+    } else {
+      iv = ix;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    uiv = uix;
+    if (uie > uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uiv = uix;
+    if (uix > uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uiv = uix;
+    if (uie < uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uiv = uix;
+    if (uix < uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uiv = uix;
+    if (uix == uie) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uiv = uix;
+    if (uie == uix) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (uie > uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uix > uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uie < uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uix < uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uix == uie) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  {
+    if (uie == uix) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  if (uix == uie) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  if (uie == uix) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    uiv = uix;
+    if (uie > uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uiv = uix;
+    if (uix > uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uiv = uix;
+    if (uie < uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uiv = uix;
+    if (uix < uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uiv = uix;
+    if (uix == uie) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uiv = uix;
+    if (uie == uix) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uie > uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uix > uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uie < uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uix < uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uix == uie) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (uie == uix) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (uix == uie) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (uie == uix) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    uiv = uix;
+    if (uie > uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uiv = uix;
+    if (uix > uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uiv = uix;
+    if (uie < uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uiv = uix;
+    if (uix < uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uiv = uix;
+    if (uix == uie) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uiv = uix;
+    if (uie == uix) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uie > uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uix > uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uie < uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uix < uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uix == uie) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (uie == uix) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  if (uix == uie) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  if (uie == uix) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    uiv = uix;
+    if (uie > uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uiv = uix;
+    if (uix > uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uiv = uix;
+    if (uie < uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uiv = uix;
+    if (uix < uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uiv = uix;
+    if (uix == uie) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uiv = uix;
+    if (uie == uix) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uie > uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uix > uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uie < uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uix < uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uix == uie) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (uie == uix) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  if (uix == uie) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  if (uie == uix) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    uiv = uix;
+    if (uie > uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uiv = uix;
+    if (uix > uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uiv = uix;
+    if (uie < uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uiv = uix;
+    if (uix < uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uiv = uix;
+    if (uix == uie) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uiv = uix;
+    if (uie == uix) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uie > uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uix > uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uie < uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uix < uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uix == uie) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (uie == uix) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  if (uix == uie) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  if (uie == uix) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture release
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    uiv = uix;
+    if (uie > uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uiv = uix;
+    if (uix > uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uiv = uix;
+    if (uie < uix) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uiv = uix;
+    if (uix < uie) {
+      uix = uie;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uiv = uix;
+    if (uix == uie) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uiv = uix;
+    if (uie == uix) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uie > uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uix > uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uie < uix) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uix < uie) {
+      uix = uie;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uix == uie) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (uie == uix) {
+      uix = uid;
+    }
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (uix == uie) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (uie == uix) {
+    uix = uid;
+  } else {
+    uiv = uix;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uir = uix == uie;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    uir = uie == uix;
+    if (uir) {
+      uix = uid;
+    } else {
+      uiv = uix;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    lv = lx;
+    if (le > lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lv = lx;
+    if (lx > le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lv = lx;
+    if (le < lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lv = lx;
+    if (lx < le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lv = lx;
+    if (lx == le) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lv = lx;
+    if (le == lx) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (le > lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (lx > le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (le < lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (lx < le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (lx == le) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (le == lx) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  if (lx == le) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  if (le == lx) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    lv = lx;
+    if (le > lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lv = lx;
+    if (lx > le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lv = lx;
+    if (le < lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lv = lx;
+    if (lx < le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lv = lx;
+    if (lx == le) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lv = lx;
+    if (le == lx) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (le > lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (lx > le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (le < lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (lx < le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (lx == le) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (le == lx) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (lx == le) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (le == lx) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    lv = lx;
+    if (le > lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lv = lx;
+    if (lx > le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lv = lx;
+    if (le < lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lv = lx;
+    if (lx < le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lv = lx;
+    if (lx == le) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lv = lx;
+    if (le == lx) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (le > lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (lx > le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (le < lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (lx < le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (lx == le) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (le == lx) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  if (lx == le) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  if (le == lx) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    lv = lx;
+    if (le > lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lv = lx;
+    if (lx > le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lv = lx;
+    if (le < lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lv = lx;
+    if (lx < le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lv = lx;
+    if (lx == le) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lv = lx;
+    if (le == lx) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (le > lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (lx > le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (le < lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (lx < le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (lx == le) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (le == lx) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (lx == le) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (le == lx) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    lv = lx;
+    if (le > lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lv = lx;
+    if (lx > le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lv = lx;
+    if (le < lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lv = lx;
+    if (lx < le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lv = lx;
+    if (lx == le) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lv = lx;
+    if (le == lx) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (le > lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (lx > le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (le < lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (lx < le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (lx == le) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (le == lx) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  if (lx == le) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  if (le == lx) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture release
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    lv = lx;
+    if (le > lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lv = lx;
+    if (lx > le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lv = lx;
+    if (le < lx) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lv = lx;
+    if (lx < le) {
+      lx = le;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lv = lx;
+    if (lx == le) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lv = lx;
+    if (le == lx) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (le > lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (lx > le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (le < lx) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (lx < le) {
+      lx = le;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (lx == le) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (le == lx) {
+      lx = ld;
+    }
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (lx == le) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (le == lx) {
+    lx = ld;
+  } else {
+    lv = lx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lr = lx == le;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    lr = le == lx;
+    if (lr) {
+      lx = ld;
+    } else {
+      lv = lx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    ulv = ulx;
+    if (ule > ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulv = ulx;
+    if (ulx > ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulv = ulx;
+    if (ule < ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulv = ulx;
+    if (ulx < ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulv = ulx;
+    if (ulx == ule) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulv = ulx;
+    if (ule == ulx) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (ule > ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ulx > ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ule < ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ulx < ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ulx == ule) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ule == ulx) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  if (ulx == ule) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  if (ule == ulx) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    ulv = ulx;
+    if (ule > ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulv = ulx;
+    if (ulx > ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulv = ulx;
+    if (ule < ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulv = ulx;
+    if (ulx < ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulv = ulx;
+    if (ulx == ule) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulv = ulx;
+    if (ule == ulx) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ule > ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ulx > ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ule < ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ulx < ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ulx == ule) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ule == ulx) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ulx == ule) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ule == ulx) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    ulv = ulx;
+    if (ule > ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulv = ulx;
+    if (ulx > ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulv = ulx;
+    if (ule < ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulv = ulx;
+    if (ulx < ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulv = ulx;
+    if (ulx == ule) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulv = ulx;
+    if (ule == ulx) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ule > ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ulx > ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ule < ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ulx < ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ulx == ule) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ule == ulx) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  if (ulx == ule) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  if (ule == ulx) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    ulv = ulx;
+    if (ule > ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulv = ulx;
+    if (ulx > ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulv = ulx;
+    if (ule < ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulv = ulx;
+    if (ulx < ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulv = ulx;
+    if (ulx == ule) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulv = ulx;
+    if (ule == ulx) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ule > ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ulx > ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ule < ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ulx < ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ulx == ule) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ule == ulx) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ulx == ule) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ule == ulx) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    ulv = ulx;
+    if (ule > ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulv = ulx;
+    if (ulx > ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulv = ulx;
+    if (ule < ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulv = ulx;
+    if (ulx < ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulv = ulx;
+    if (ulx == ule) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulv = ulx;
+    if (ule == ulx) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ule > ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ulx > ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ule < ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ulx < ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ulx == ule) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ule == ulx) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  if (ulx == ule) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  if (ule == ulx) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture release
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    ulv = ulx;
+    if (ule > ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulv = ulx;
+    if (ulx > ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulv = ulx;
+    if (ule < ulx) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulv = ulx;
+    if (ulx < ule) {
+      ulx = ule;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulv = ulx;
+    if (ulx == ule) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulv = ulx;
+    if (ule == ulx) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ule > ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ulx > ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ule < ulx) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ulx < ule) {
+      ulx = ule;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ulx == ule) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ule == ulx) {
+      ulx = uld;
+    }
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ulx == ule) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ule == ulx) {
+    ulx = uld;
+  } else {
+    ulv = ulx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulr = ulx == ule;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ulr = ule == ulx;
+    if (ulr) {
+      ulx = uld;
+    } else {
+      ulv = ulx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    llv = llx;
+    if (lle > llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llv = llx;
+    if (llx > lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llv = llx;
+    if (lle < llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llv = llx;
+    if (llx < lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llv = llx;
+    if (llx == lle) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llv = llx;
+    if (lle == llx) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (lle > llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (llx > lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (lle < llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (llx < lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (llx == lle) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (lle == llx) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  if (llx == lle) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  if (lle == llx) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    llv = llx;
+    if (lle > llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llv = llx;
+    if (llx > lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llv = llx;
+    if (lle < llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llv = llx;
+    if (llx < lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llv = llx;
+    if (llx == lle) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llv = llx;
+    if (lle == llx) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (lle > llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (llx > lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (lle < llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (llx < lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (llx == lle) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (lle == llx) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (llx == lle) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (lle == llx) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    llv = llx;
+    if (lle > llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llv = llx;
+    if (llx > lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llv = llx;
+    if (lle < llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llv = llx;
+    if (llx < lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llv = llx;
+    if (llx == lle) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llv = llx;
+    if (lle == llx) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (lle > llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (llx > lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (lle < llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (llx < lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (llx == lle) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (lle == llx) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  if (llx == lle) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  if (lle == llx) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    llv = llx;
+    if (lle > llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llv = llx;
+    if (llx > lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llv = llx;
+    if (lle < llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llv = llx;
+    if (llx < lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llv = llx;
+    if (llx == lle) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llv = llx;
+    if (lle == llx) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (lle > llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (llx > lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (lle < llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (llx < lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (llx == lle) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (lle == llx) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (llx == lle) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (lle == llx) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    llv = llx;
+    if (lle > llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llv = llx;
+    if (llx > lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llv = llx;
+    if (lle < llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llv = llx;
+    if (llx < lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llv = llx;
+    if (llx == lle) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llv = llx;
+    if (lle == llx) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (lle > llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (llx > lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (lle < llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (llx < lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (llx == lle) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (lle == llx) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  if (llx == lle) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  if (lle == llx) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture release
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    llv = llx;
+    if (lle > llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llv = llx;
+    if (llx > lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llv = llx;
+    if (lle < llx) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llv = llx;
+    if (llx < lle) {
+      llx = lle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llv = llx;
+    if (llx == lle) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llv = llx;
+    if (lle == llx) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (lle > llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (llx > lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (lle < llx) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (llx < lle) {
+      llx = lle;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (llx == lle) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (lle == llx) {
+      llx = lld;
+    }
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (llx == lle) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (lle == llx) {
+    llx = lld;
+  } else {
+    llv = llx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llr = llx == lle;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    llr = lle == llx;
+    if (llr) {
+      llx = lld;
+    } else {
+      llv = llx;
+    }
+  }
+
+#pragma omp atomic compare capture
+  {
+    ullv = ullx;
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullv = ullx;
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullv = ullx;
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullv = ullx;
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullv = ullx;
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullv = ullx;
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  {
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  if (ullx == ulle) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  if (ulle == ullx) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+#pragma omp atomic compare capture
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+
+#pragma omp atomic compare capture acq_rel
+  {
+    ullv = ullx;
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullv = ullx;
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullv = ullx;
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullv = ullx;
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullv = ullx;
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullv = ullx;
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ullx == ulle) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  if (ulle == ullx) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+#pragma omp atomic compare capture acq_rel
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+
+#pragma omp atomic compare capture acquire
+  {
+    ullv = ullx;
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullv = ullx;
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullv = ullx;
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullv = ullx;
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullv = ullx;
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullv = ullx;
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  if (ullx == ulle) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  if (ulle == ullx) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+#pragma omp atomic compare capture acquire
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+
+#pragma omp atomic compare capture relaxed
+  {
+    ullv = ullx;
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullv = ullx;
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullv = ullx;
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullv = ullx;
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullv = ullx;
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullv = ullx;
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ullx == ulle) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  if (ulle == ullx) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+#pragma omp atomic compare capture relaxed
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+
+#pragma omp atomic compare capture release
+  {
+    ullv = ullx;
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullv = ullx;
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullv = ullx;
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullv = ullx;
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullv = ullx;
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullv = ullx;
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  {
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  if (ullx == ulle) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  if (ulle == ullx) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture release
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+#pragma omp atomic compare capture release
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+
+#pragma omp atomic compare capture seq_cst
+  {
+    ullv = ullx;
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullv = ullx;
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullv = ullx;
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullv = ullx;
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullv = ullx;
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullv = ullx;
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ulle > ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ullx > ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ulle < ullx) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ullx < ulle) {
+      ullx = ulle;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ullx == ulle) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    if (ulle == ullx) {
+      ullx = ulld;
+    }
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ullx == ulle) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  if (ulle == ullx) {
+    ullx = ulld;
+  } else {
+    ullv = ullx;
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullr = ullx == ulle;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+#pragma omp atomic compare capture seq_cst
+  {
+    ullr = ulle == ullx;
+    if (ullr) {
+      ullx = ulld;
+    } else {
+      ullv = ullx;
+    }
+  }
+}
+
 #endif
 // CHECK-LABEL: @foo(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[CX:%.*]] = alloca i8, align 1
 // CHECK-NEXT:    [[CE:%.*]] = alloca i8, align 1
 // CHECK-NEXT:    [[CD:%.*]] = alloca i8, align 1
 // CHECK-NEXT:    [[UCX:%.*]] = alloca i8, align 1
 // CHECK-NEXT:    [[UCE:%.*]] = alloca i8, align 1