[clang] c4a90db - [Clang][OpenMP] Add the codegen support for `atomic compare capture`
Shilei Tian via cfe-commits
cfe-commits at lists.llvm.org
Thu Jun 2 18:38:26 PDT 2022
Author: Shilei Tian
Date: 2022-06-02T21:38:21-04:00
New Revision: c4a90db72064cca70c51b9c49212fa54d34b02ba
URL: https://github.com/llvm/llvm-project/commit/c4a90db72064cca70c51b9c49212fa54d34b02ba
DIFF: https://github.com/llvm/llvm-project/commit/c4a90db72064cca70c51b9c49212fa54d34b02ba.diff
LOG: [Clang][OpenMP] Add the codegen support for `atomic compare capture`
This patch adds the codegen support for `atomic compare capture` in clang.
Reviewed By: ABataev
Differential Revision: https://reviews.llvm.org/D120290
Added:
Modified:
clang/include/clang/AST/StmtOpenMP.h
clang/lib/AST/StmtOpenMP.cpp
clang/lib/CodeGen/CGStmtOpenMP.cpp
clang/lib/Sema/SemaOpenMP.cpp
clang/lib/Serialization/ASTReaderStmt.cpp
clang/lib/Serialization/ASTWriterStmt.cpp
clang/test/OpenMP/atomic_compare_codegen.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/StmtOpenMP.h b/clang/include/clang/AST/StmtOpenMP.h
index dfaf8b5a77385..4ebe7f44aa7ad 100644
--- a/clang/include/clang/AST/StmtOpenMP.h
+++ b/clang/include/clang/AST/StmtOpenMP.h
@@ -2848,6 +2848,9 @@ class OMPAtomicDirective : public OMPExecutableDirective {
/// 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.
@@ -2872,6 +2875,7 @@ class OMPAtomicDirective : public OMPExecutableDirective {
POS_UpdateExpr,
POS_D,
POS_Cond,
+ POS_R,
};
/// Set 'x' part of the associated expression/statement.
@@ -2884,6 +2888,8 @@ class OMPAtomicDirective : public OMPExecutableDirective {
}
/// 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.
@@ -2897,6 +2903,8 @@ class OMPAtomicDirective : public OMPExecutableDirective {
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:
@@ -2911,6 +2919,9 @@ class OMPAtomicDirective : public OMPExecutableDirective {
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'
@@ -2963,6 +2974,9 @@ class OMPAtomicDirective : public OMPExecutableDirective {
/// 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]);
@@ -2970,6 +2984,13 @@ class OMPAtomicDirective : public OMPExecutableDirective {
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]);
diff --git a/clang/lib/AST/StmtOpenMP.cpp b/clang/lib/AST/StmtOpenMP.cpp
index 3535b0620ee50..74d1020e15b66 100644
--- a/clang/lib/AST/StmtOpenMP.cpp
+++ b/clang/lib/AST/StmtOpenMP.cpp
@@ -868,15 +868,17 @@ 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;
}
@@ -884,7 +886,7 @@ 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,
diff --git a/clang/lib/CodeGen/CGStmtOpenMP.cpp b/clang/lib/CodeGen/CGStmtOpenMP.cpp
index f509d6fa935f6..5232edd6a4afc 100644
--- a/clang/lib/CodeGen/CGStmtOpenMP.cpp
+++ b/clang/lib/CodeGen/CGStmtOpenMP.cpp
@@ -6159,8 +6159,10 @@ static void emitOMPAtomicCaptureExpr(CodeGenFunction &CGF,
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();
@@ -6196,24 +6198,47 @@ static void emitOMPAtomicCompareExpr(CodeGenFunction &CGF,
llvm::Value *EVal = EmitRValueWithCastIfNeeded(X, E);
llvm::Value *DVal = D ? EmitRValueWithCastIfNeeded(X, D) : nullptr;
+ if (auto *CI = dyn_cast<llvm::ConstantInt>(EVal))
+ EVal = CGF.Builder.CreateIntCast(
+ CI, XLVal.getAddress(CGF).getElementType(),
+ E->getType()->hasSignedIntegerRepresentation());
+ 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()->hasSignedIntegerRepresentation(),
X->getType().isVolatileQualified()};
llvm::OpenMPIRBuilder::AtomicOpValue VOpVal, ROpVal;
+ if (V) {
+ LValue LV = CGF.EmitLValue(V);
+ Address Addr = LV.getAddress(CGF);
+ VOpVal = {Addr.getPointer(), Addr.getElementType(),
+ V->getType()->hasSignedIntegerRepresentation(),
+ V->getType().isVolatileQualified()};
+ }
+ if (R) {
+ LValue LV = CGF.EmitLValue(R);
+ Address Addr = LV.getAddress(CGF);
+ ROpVal = {Addr.getPointer(), Addr.getElementType(),
+ R->getType()->hasSignedIntegerRepresentation(),
+ R->getType().isVolatileQualified()};
+ }
CGF.Builder.restoreIP(OMPBuilder.createAtomicCompare(
CGF.Builder, XOpVal, VOpVal, ROpVal, EVal, DVal, AO, Op, IsXBinopExpr,
- /* IsPostfixUpdate */ false, /* IsFailOnly */ false));
+ 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);
@@ -6230,15 +6255,8 @@ static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
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:
@@ -6365,12 +6383,12 @@ void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
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();
@@ -6392,8 +6410,9 @@ void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
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,
diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp
index 04770975005da..803e0139d40ec 100644
--- a/clang/lib/Sema/SemaOpenMP.cpp
+++ b/clang/lib/Sema/SemaOpenMP.cpp
@@ -11632,6 +11632,7 @@ class OpenMPAtomicCompareCaptureChecker final
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);
@@ -11661,6 +11662,8 @@ class OpenMPAtomicCompareCaptureChecker final
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) {
@@ -11966,6 +11969,8 @@ bool OpenMPAtomicCompareCaptureChecker::checkStmt(Stmt *S,
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;
@@ -12141,8 +12146,10 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
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.
@@ -12538,8 +12545,16 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
<< 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);
@@ -12547,7 +12562,7 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
Diag(ErrorInfo.ErrorLoc, diag::err_omp_atomic_compare)
<< ErrorInfo.ErrorRange;
Diag(ErrorInfo.NoteLoc, diag::note_omp_atomic_compare)
- << ErrorInfo.Error << ErrorInfo.NoteRange;
+ << ErrorInfo.Error << ErrorInfo.NoteRange;
return StmtError();
}
X = Checker.getX();
@@ -12563,7 +12578,7 @@ StmtResult Sema::ActOnOpenMPAtomicDirective(ArrayRef<OMPClause *> Clauses,
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,
diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp
index 09342de1eee96..bb324a76020c7 100644
--- a/clang/lib/Serialization/ASTReaderStmt.cpp
+++ b/clang/lib/Serialization/ASTReaderStmt.cpp
@@ -2431,6 +2431,7 @@ void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *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) {
diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp
index 587aad3f11e06..cd4b84421a28c 100644
--- a/clang/lib/Serialization/ASTWriterStmt.cpp
+++ b/clang/lib/Serialization/ASTWriterStmt.cpp
@@ -2318,6 +2318,7 @@ void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
VisitOMPExecutableDirective(D);
Record.writeBool(D->isXLHSInRHSPart());
Record.writeBool(D->isPostfixUpdate());
+ Record.writeBool(D->isFailOnly());
Code = serialization::STMT_OMP_ATOMIC_DIRECTIVE;
}
diff --git a/clang/test/OpenMP/atomic_compare_codegen.cpp b/clang/test/OpenMP/atomic_compare_codegen.cpp
index 825832399e3c4..c4032a862cc22 100644
--- a/clang/test/OpenMP/atomic_compare_codegen.cpp
+++ b/clang/test/OpenMP/atomic_compare_codegen.cpp
@@ -1945,6 +1945,7759 @@ void foo(void) {
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:
More information about the cfe-commits
mailing list