Move to new C++ binding interface that requires isl::quota annotations [RFC]

[philip.pfaffe]

I think this diff is too large and should be split into at least two parts:

1. The implementation of isl::quota, and possibly a small unittest showcasing how it's intended to be used
2. Update of the APIs

[Meinersbur]

Could you add a paragraph about what (and) this is trying to accomplish into the summary? Even better, add documentation?

What's your plan to converge this to/with an official isl C++ binding?

Prepend the title with [Polly].

Virtual destructors are a quite heavy machinery. Are you sure it is worth adding/are there alternatives?

But I very much like the idea of fast-failing on out-of-quota! Should we generalize this to all kind of errors?

lib/External/isl/include/isl/isl-noexceptions.h

62

what's the code style here?

106

Who is "I"? The author of this line (i.e. @grosser)? I think what is meant is somebody who uses quota_unclear in their code, although it seems it is not meant to be used directly.

lib/External/isl/isl_ctx.c

115

Forgotten/leftover?

include/polly/ScopInfo.h

public:
   void invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB = nullptr);
 
   /// Get the invalid context for this Scop.
   ///
   /// @return The invalid context of this Scop.
   isl::set getInvalidContext() const;
 
   /// Return true if and only if the InvalidContext is trivial (=empty).
-  bool hasTrivialInvalidContext() const { return InvalidContext.is_empty(); }
+  bool hasTrivialInvalidContext() const {
+    return InvalidContext.is_empty(isl::quota::unclear);
+  }
 
   /// A vector of memory accesses that belong to an alias group.
   using AliasGroupTy = SmallVector<MemoryAccess *, 4>;
 
   /// A vector of alias groups.
   using AliasGroupVectorTy = SmallVector<Scop::AliasGroupTy, 4>;
 
   /// Build the alias checks for this SCoP.

lib/Analysis/ScopBuilder.cpp

void ScopBuilder::checkForReductions(ScopStmt &Stmt) {
 
   // Then check each possible candidate pair.
   for (const auto &CandidatePair : Candidates) {
     bool Valid = true;
     isl::map LoadAccs = CandidatePair.first->getAccessRelation();
     isl::map StoreAccs = CandidatePair.second->getAccessRelation();
 
     // Skip those with obviously unequal base addresses.
-    if (!LoadAccs.has_equal_space(StoreAccs)) {
+    if (!LoadAccs.has_equal_space(StoreAccs, isl::quota::unclear)) {
       continue;
     }
 
     // And check if the remaining for overlap with other memory accesses.
     isl::map AllAccsRel = LoadAccs.unite(StoreAccs);
     AllAccsRel = AllAccsRel.intersect_domain(Stmt.getDomain());
     isl::set AllAccs = AllAccsRel.range();
 
     for (MemoryAccess *MA : Stmt) {
       if (MA == CandidatePair.first || MA == CandidatePair.second)
         continue;
 
       isl::map AccRel =
           MA->getAccessRelation().intersect_domain(Stmt.getDomain());
       isl::set Accs = AccRel.range();
 
-      if (AllAccs.has_equal_space(Accs)) {
+      if (AllAccs.has_equal_space(Accs, isl::quota::unclear)) {
         isl::set OverlapAccs = Accs.intersect(AllAccs);
-        Valid = Valid && OverlapAccs.is_empty();
+        Valid = Valid && OverlapAccs.is_empty(isl::quota::unclear);
       }
     }
 
     if (!Valid)
       continue;
 
     const LoadInst *Load =
         dyn_cast<const LoadInst>(CandidatePair.first->getAccessInstruction());

lib/Analysis/ScopInfo.cpp

isl::space ScopArrayInfo::getSpace() const {
   return Space;
 }
 
 bool ScopArrayInfo::isReadOnly() {
   isl::union_set WriteSet = S.getWrites().range();
   isl::space Space = getSpace();
   WriteSet = WriteSet.extract_set(Space);
 
-  return bool(WriteSet.is_empty());
+  return bool(WriteSet.is_empty(isl::quota::unclear));
 }
 
 bool ScopArrayInfo::isCompatibleWith(const ScopArrayInfo *Array) const {
   if (Array->getElementType() != getElementType())
     return false;
 
   if (Array->getNumberOfDimensions() != getNumberOfDimensions())
     return false;
bool MemoryAccess::isStrideX(isl::map Schedule, int StrideWidth) const {
   bool IsStrideX;
 
   Stride = getStride(Schedule);
   StrideX = isl::set::universe(Stride.get_space());
   for (unsigned i = 0; i < StrideX.dim(isl::dim::set) - 1; i++)
     StrideX = StrideX.fix_si(isl::dim::set, i, 0);
   StrideX = StrideX.fix_si(isl::dim::set, StrideX.dim(isl::dim::set) - 1,
                            StrideWidth);
-  IsStrideX = Stride.is_subset(StrideX);
+  IsStrideX = Stride.is_subset(StrideX, isl::quota::unclear);
 
   return IsStrideX;
 }
 
 bool MemoryAccess::isStrideZero(isl::map Schedule) const {
   return isStrideX(Schedule, 0);
 }
 
 bool MemoryAccess::isStrideOne(isl::map Schedule) const {
   return isStrideX(Schedule, 1);
 }
 
 void MemoryAccess::setAccessRelation(isl::map NewAccess) {
   AccessRelation = NewAccess;
 }
 
 void MemoryAccess::setNewAccessRelation(isl::map NewAccess) {
   assert(NewAccess);
 
 #ifndef NDEBUG
   // Check domain space compatibility.
   isl::space NewSpace = NewAccess.get_space();
   isl::space NewDomainSpace = NewSpace.domain();
   isl::space OriginalDomainSpace = getStatement()->getDomainSpace();
-  assert(OriginalDomainSpace.has_equal_tuples(NewDomainSpace));
+  assert(OriginalDomainSpace.has_equal_tuples(NewDomainSpace,
+                                              isl::quota::ret_true));
 
   // Reads must be executed unconditionally. Writes might be executed in a
   // subdomain only.
   if (isRead()) {
     // Check whether there is an access for every statement instance.
     isl::set StmtDomain = getStatement()->getDomain();
     StmtDomain =
         StmtDomain.intersect_params(getStatement()->getParent()->getContext());
     isl::set NewDomain = NewAccess.domain();
-    assert(StmtDomain.is_subset(NewDomain) &&
+    assert(StmtDomain.is_subset(NewDomain, isl::quota::ret_true) &&
            "Partial READ accesses not supported");
   }
 
   isl::space NewAccessSpace = NewAccess.get_space();
-  assert(NewAccessSpace.has_tuple_id(isl::dim::set) &&
+  assert(NewAccessSpace.has_tuple_id(isl::dim::set, isl::quota::ret_true) &&
          "Must specify the array that is accessed");
   isl::id NewArrayId = NewAccessSpace.get_tuple_id(isl::dim::set);
   auto *SAI = static_cast<ScopArrayInfo *>(NewArrayId.get_user());
   assert(SAI && "Must set a ScopArrayInfo");
 
   if (SAI->isArrayKind() && SAI->getBasePtrOriginSAI()) {
     InvariantEquivClassTy *EqClass =
         getStatement()->getParent()->lookupInvariantEquivClass(
#endif
   NewAccess = NewAccess.gist_domain(getStatement()->getDomain());
   NewAccessRelation = NewAccess;
 }
 
 bool MemoryAccess::isLatestPartialAccess() const {
   isl::set StmtDom = getStatement()->getDomain();
   isl::set AccDom = getLatestAccessRelation().domain();
 
-  return !StmtDom.is_subset(AccDom);
+  return !StmtDom.is_subset(AccDom, isl::quota::unclear);
 }
 
 //===----------------------------------------------------------------------===//
 
 isl::map ScopStmt::getSchedule() const {
   isl::set Domain = getDomain();
-  if (Domain.is_empty())
+  if (Domain.is_empty(isl::quota::unclear))
     return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
   auto Schedule = getParent()->getSchedule();
   if (!Schedule)
     return nullptr;
   Schedule = Schedule.intersect_domain(isl::union_set(Domain));
-  if (Schedule.is_empty())
+  if (Schedule.is_empty(isl::quota::unclear))
     return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
   isl::map M = M.from_union_map(Schedule);
   M = M.coalesce();
   M = M.gist_domain(Domain);
   M = M.coalesce();
   return M;
 }
 
 void ScopStmt::restrictDomain(isl::set NewDomain) {
-  assert(NewDomain.is_subset(Domain) &&
+  assert(NewDomain.is_subset(Domain, isl::quota::ret_true) &&
          "New domain is not a subset of old domain!");
   Domain = NewDomain;
 }
 
 void ScopStmt::addAccess(MemoryAccess *Access, bool Prepend) {
   Instruction *AccessInst = Access->getAccessInstruction();
 
   if (Access->isArrayKind()) {
static void buildMinMaxAccess(isl::set Set,
   //            9          |     0.40
   //           10          |     1.54
   //           11          |     6.78
   //           12          |    30.38
   //
   if (isl_set_n_param(Set.get()) > RunTimeChecksMaxParameters) {
     unsigned InvolvedParams = 0;
     for (unsigned u = 0, e = isl_set_n_param(Set.get()); u < e; u++)
-      if (Set.involves_dims(isl::dim::param, u, 1))
+      if (Set.involves_dims(isl::dim::param, u, 1, isl::quota::unclear))
         InvolvedParams++;
 
     if (InvolvedParams > RunTimeChecksMaxParameters) {
       Aborted = true;
       return;
     }
   }
 
for (MemoryAccess *MA : AliasGroup)
     Accesses = Accesses.add_map(MA->getAccessRelation());
 
   Accesses = Accesses.intersect_domain(Domains);
   isl::union_set Locations = Accesses.range();
   Locations = Locations.coalesce();
   Locations = Locations.detect_equalities();
 
   bool Aborted = false;
-  auto Lambda = [&MinMaxAccesses, &S, &Aborted](isl::set Set) -> isl::stat {
+  auto Lambda = [&MinMaxAccesses, &S, &Aborted](isl::set Set) {
     buildMinMaxAccess(Set, MinMaxAccesses, S, Aborted);
-    return isl::stat::ok;
+    return;
   };
   Locations.foreach_set(Lambda);
 
   return !Aborted;
 }
 
 /// Helper to treat non-affine regions and basic blocks the same.
 ///
for (auto *RN : RTraversal) {
 
     bool ContainsErrorBlock = containsErrorBlock(RN, getRegion(), LI, DT);
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
     isl::set &Domain = DomainMap[BB];
     assert(Domain && "Cannot propagate a nullptr");
 
     isl::set InvalidDomain = InvalidDomainMap[BB];
 
-    bool IsInvalidBlock = ContainsErrorBlock || Domain.is_subset(InvalidDomain);
+    bool IsInvalidBlock = ContainsErrorBlock ||
+                          Domain.is_subset(InvalidDomain, isl::quota::unclear);
 
     if (!IsInvalidBlock) {
       InvalidDomain = InvalidDomain.intersect(Domain);
     } else {
       InvalidDomain = Domain;
       isl::set DomPar = Domain.params();
       recordAssumption(ERRORBLOCK, DomPar, BB->getTerminator()->getDebugLoc(),
                        AS_RESTRICTION);
       Domain = nullptr;
     }
 
-    if (InvalidDomain.is_empty()) {
+    if (InvalidDomain.is_empty(isl::quota::unclear)) {
       InvalidDomainMap[BB] = InvalidDomain;
       continue;
     }
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     auto *TI = BB->getTerminator();
     unsigned NumSuccs = RN->isSubRegion() ? 1 : TI->getNumSuccessors();
     for (unsigned u = 0; u < NumSuccs; u++) {
bool Scop::canAlwaysBeHoisted(MemoryAccess *MA, bool StmtInvalidCtxIsEmpty,
   return true;
 }
 
 void Scop::addInvariantLoads(ScopStmt &Stmt, InvariantAccessesTy &InvMAs) {
   if (InvMAs.empty())
     return;
 
   isl::set StmtInvalidCtx = Stmt.getInvalidContext();
-  bool StmtInvalidCtxIsEmpty = StmtInvalidCtx.is_empty();
+  bool StmtInvalidCtxIsEmpty = StmtInvalidCtx.is_empty(isl::quota::unclear);
 
   // Get the context under which the statement is executed but remove the error
   // context under which this statement is reached.
   isl::set DomainCtx = Stmt.getDomain().params();
   DomainCtx = DomainCtx.subtract(StmtInvalidCtx);
 
   if (isl_set_n_basic_set(DomainCtx.get()) >= MaxDisjunctsInDomain) {
     auto *AccInst = InvMAs.front().MA->getAccessInstruction();
for (auto &InvMA : InvMAs) {
     // Check for another invariant access that accesses the same location as
     // MA and if found consolidate them. Otherwise create a new equivalence
     // class at the end of InvariantEquivClasses.
     LoadInst *LInst = cast<LoadInst>(MA->getAccessInstruction());
     Type *Ty = LInst->getType();
     const SCEV *PointerSCEV = SE->getSCEV(LInst->getPointerOperand());
 
     isl::set MAInvalidCtx = MA->getInvalidContext();
-    bool NonHoistableCtxIsEmpty = NHCtx.is_empty();
-    bool MAInvalidCtxIsEmpty = MAInvalidCtx.is_empty();
+    bool NonHoistableCtxIsEmpty = NHCtx.is_empty(isl::quota::unclear);
+    bool MAInvalidCtxIsEmpty = MAInvalidCtx.is_empty(isl::quota::unclear);
 
     isl::set MACtx;
     // Check if we know that this pointer can be speculatively accessed.
     if (canAlwaysBeHoisted(MA, StmtInvalidCtxIsEmpty, MAInvalidCtxIsEmpty,
                            NonHoistableCtxIsEmpty)) {
       MACtx = isl::set::universe(DomainCtx.get_space());
     } else {
       MACtx = DomainCtx;
for (auto &IAClass : InvariantEquivClasses) {
       // SCoP. If this happens we cannot consolidate the loads but need to
       // create a new invariant load equivalence class.
       auto &MAs = IAClass.InvariantAccesses;
       if (!MAs.empty()) {
         auto *LastMA = MAs.front();
 
         isl::set AR = MA->getAccessRelation().range();
         isl::set LastAR = LastMA->getAccessRelation().range();
-        bool SameAR = AR.is_equal(LastAR);
+        bool SameAR = AR.is_equal(LastAR, isl::quota::unclear);
 
         if (!SameAR)
           continue;
       }
 
       // Add MA to the list of accesses that are in this class.
       MAs.push_front(MA);
 

 /// arise in h264.
 ///
 /// @param AccessRange The range to check for complexity.
 ///
 /// @returns True if the access range is too complex.
 static bool isAccessRangeTooComplex(isl::set AccessRange) {
   unsigned NumTotalDims = 0;
 
-  auto CountDimensions = [&NumTotalDims](isl::basic_set BSet) -> isl::stat {
+  auto CountDimensions = [&NumTotalDims](isl::basic_set BSet) {
     NumTotalDims += BSet.dim(isl::dim::div);
     NumTotalDims += BSet.dim(isl::dim::set);
-    return isl::stat::ok;
+    return;
   };
 
   AccessRange.foreach_basic_set(CountDimensions);
 
   if (NumTotalDims > MaxDimensionsInAccessRange)
     return true;
 
   return false;
isl::set Scop::getNonHoistableCtx(MemoryAccess *Access, isl::union_map Writes) {
   // that it is invariant, thus it will be hoisted too. However, if there is
   // no base pointer origin we check that the base pointer is defined
   // outside the region.
   auto *LI = cast<LoadInst>(Access->getAccessInstruction());
   if (hasNonHoistableBasePtrInScop(Access, Writes))
     return nullptr;
 
   isl::map AccessRelation = Access->getAccessRelation();
-  assert(!AccessRelation.is_empty());
+  assert(!AccessRelation.is_empty(isl::quota::ret_false));
 
-  if (AccessRelation.involves_dims(isl::dim::in, 0, Stmt.getNumIterators()))
+  if (AccessRelation.involves_dims(isl::dim::in, 0, Stmt.getNumIterators(),
+                                   isl::quota::unclear))
     return nullptr;
 
   AccessRelation = AccessRelation.intersect_domain(Stmt.getDomain());
   isl::set SafeToLoad;
 
   auto &DL = getFunction().getParent()->getDataLayout();
   if (isSafeToLoadUnconditionally(LI->getPointerOperand(), LI->getAlignment(),
                                   DL)) {
     SafeToLoad = isl::set::universe(AccessRelation.get_space().range());
   } else if (BB != LI->getParent()) {
     // Skip accesses in non-affine subregions as they might not be executed
     // under the same condition as the entry of the non-affine subregion.
     return nullptr;
   } else {
     SafeToLoad = AccessRelation.range();
   }
 
   if (isAccessRangeTooComplex(AccessRelation.range()))
     return nullptr;
 
   isl::union_map Written = Writes.intersect_range(SafeToLoad);
   isl::set WrittenCtx = Written.params();
-  bool IsWritten = !WrittenCtx.is_empty();
+  bool IsWritten = !WrittenCtx.is_empty(isl::quota::unclear);
 
   if (!IsWritten)
     return WrittenCtx;
 
   WrittenCtx = WrittenCtx.remove_divs();
   bool TooComplex =
       isl_set_n_basic_set(WrittenCtx.get()) >= MaxDisjunctsInDomain;
   if (TooComplex || !isRequiredInvariantLoad(LI))

 bool Scop::hasFeasibleRuntimeContext() const {
   auto PositiveContext = getAssumedContext();
   auto NegativeContext = getInvalidContext();
   PositiveContext = addNonEmptyDomainConstraints(PositiveContext);
   // addNonEmptyDomainConstraints returns null if ScopStmts have a null domain
   if (!PositiveContext)
     return false;
 
-  bool IsFeasible = !(PositiveContext.is_empty() ||
-                      PositiveContext.is_subset(NegativeContext));
+  bool IsFeasible =
+      !(PositiveContext.is_empty(isl::quota::unclear) ||
+        PositiveContext.is_subset(NegativeContext, isl::quota::unclear));
   if (!IsFeasible)
     return false;
 
   auto DomainContext = getDomains().params();
-  IsFeasible = !DomainContext.is_subset(NegativeContext);
-  IsFeasible &= !Context.is_subset(NegativeContext);
+  IsFeasible = !DomainContext.is_subset(NegativeContext, isl::quota::unclear);
+  IsFeasible &= !Context.is_subset(NegativeContext, isl::quota::unclear);
 
   return IsFeasible;
 }
 
 static std::string toString(AssumptionKind Kind) {
   switch (Kind) {
   case ALIASING:
     return "No-aliasing";
static std::string toString(AssumptionKind Kind) {
   case DELINEARIZATION:
     return "Delinearization";
   }
   llvm_unreachable("Unknown AssumptionKind!");
 }
 
 bool Scop::isEffectiveAssumption(isl::set Set, AssumptionSign Sign) {
   if (Sign == AS_ASSUMPTION) {
-    if (Context.is_subset(Set))
+    if (Context.is_subset(Set, isl::quota::unclear))
       return false;
 
-    if (AssumedContext.is_subset(Set))
+    if (AssumedContext.is_subset(Set, isl::quota::unclear))
       return false;
   } else {
-    if (Set.is_disjoint(Context))
+    if (Set.is_disjoint(Context, isl::quota::unclear))
       return false;
 
-    if (Set.is_subset(InvalidContext))
+    if (Set.is_subset(InvalidContext, isl::quota::unclear))
       return false;
   }
   return true;
 }
 
 bool Scop::trackAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
                            AssumptionSign Sign, BasicBlock *BB) {
   if (PollyRemarksMinimal && !isEffectiveAssumption(Set, Sign))
     return false;
 
   // Do never emit trivial assumptions as they only clutter the output.
   if (!PollyRemarksMinimal) {
     isl::set Univ;
     if (Sign == AS_ASSUMPTION)
       Univ = isl::set::universe(Set.get_space());
 
-    bool IsTrivial = (Sign == AS_RESTRICTION && Set.is_empty()) ||
-                     (Sign == AS_ASSUMPTION && Univ.is_equal(Set));
+    bool IsTrivial =
+        (Sign == AS_RESTRICTION && Set.is_empty(isl::quota::unclear)) ||
+        (Sign == AS_ASSUMPTION && Univ.is_equal(Set, isl::quota::unclear));
 
     if (IsTrivial)
       return false;
   }
 
   switch (Kind) {
   case ALIASING:
     AssumptionsAliasing++;
void Scop::addAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
   if (Sign == AS_ASSUMPTION)
     AssumedContext = AssumedContext.intersect(Set).coalesce();
   else
     InvalidContext = InvalidContext.unite(Set).coalesce();
 }
 
 void Scop::recordAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
                             AssumptionSign Sign, BasicBlock *BB) {
-  assert((Set.is_params() || BB) &&
+  assert((Set.is_params(isl::quota::ret_true) || BB) &&
          "Assumptions without a basic block must be parameter sets");
   RecordedAssumptions.push_back({Kind, Sign, Set, Loc, BB});
 }
 
 void Scop::addRecordedAssumptions() {
   while (!RecordedAssumptions.empty()) {
     Assumption AS = RecordedAssumptions.pop_back_val();
 

 }
 
 bool Scop::restrictDomains(isl::union_set Domain) {
   bool Changed = false;
   for (ScopStmt &Stmt : *this) {
     isl::union_set StmtDomain = isl::union_set(Stmt.getDomain());
     isl::union_set NewStmtDomain = StmtDomain.intersect(Domain);
 
-    if (StmtDomain.is_subset(NewStmtDomain))
+    if (StmtDomain.is_subset(NewStmtDomain, isl::quota::unclear))
       continue;
 
     Changed = true;
 
     NewStmtDomain = NewStmtDomain.coalesce();
 
-    if (NewStmtDomain.is_empty())
+    if (NewStmtDomain.is_empty(isl::quota::unclear))
       Stmt.restrictDomain(isl::set::empty(Stmt.getDomainSpace()));
     else
       Stmt.restrictDomain(isl::set(NewStmtDomain));
   }
   return Changed;
 }
 
 ScalarEvolution *Scop::getSE() const { return SE; }

 //
 // @param USet   A union set describing the elements for which to generate a
 //               mapping.
 // @param N      The dimension to map to.
 // @returns      A mapping from USet to its N-th dimension.
 static isl::multi_union_pw_aff mapToDimension(isl::union_set USet, int N) {
   assert(N >= 0);
   assert(USet);
-  assert(!USet.is_empty());
+  assert(!USet.is_empty(isl::quota::ret_false));
 
   auto Result = isl::union_pw_multi_aff::empty(USet.get_space());
 
-  auto Lambda = [&Result, N](isl::set S) -> isl::stat {
+  auto Lambda = [&Result, N](isl::set S) {
     int Dim = S.dim(isl::dim::set);
     auto PMA = isl::pw_multi_aff::project_out_map(S.get_space(), isl::dim::set,
                                                   N, Dim - N);
     if (N > 1)
       PMA = PMA.drop_dims(isl::dim::out, 0, N - 1);
 
     Result = Result.add_pw_multi_aff(PMA);
-    return isl::stat::ok;
+    return;
   };
 
   USet.foreach_set(Lambda);
 
   return isl::multi_union_pw_aff(isl::union_pw_multi_aff(Result));
 }
 
 void Scop::addScopStmt(BasicBlock *BB, StringRef Name, Loop *SurroundingLoop,
void Scop::addScopStmt(Region *R, StringRef Name, Loop *SurroundingLoop,
   }
 }
 
 ScopStmt *Scop::addScopStmt(isl::map SourceRel, isl::map TargetRel,
                             isl::set Domain) {
 #ifndef NDEBUG
   isl::set SourceDomain = SourceRel.domain();
   isl::set TargetDomain = TargetRel.domain();
-  assert(Domain.is_subset(TargetDomain) &&
+  assert(Domain.is_subset(TargetDomain, isl::quota::ret_true) &&
          "Target access not defined for complete statement domain");
-  assert(Domain.is_subset(SourceDomain) &&
+  assert(Domain.is_subset(SourceDomain, isl::quota::ret_true) &&
          "Source access not defined for complete statement domain");
 #endif
   Stmts.emplace_back(*this, SourceRel, TargetRel, Domain);
   CopyStmtsNum++;
   return &(Stmts.back());
 }
 
 void Scop::buildSchedule(LoopInfo &LI) {
for (MemoryAccess *MA : Stmt) {
       if (MA->isLatestAnyPHIKind()) {
         Result.NumPHIWrites += 1;
         if (IsInLoop)
           Result.NumPHIWritesInLoops += 1;
       }
 
       isl::set AccSet =
           MA->getAccessRelation().intersect_domain(Domain).range();
-      if (AccSet.is_singleton()) {
+      if (AccSet.is_singleton(isl::quota::unclear)) {
         Result.NumSingletonWrites += 1;
         if (IsInLoop)
           Result.NumSingletonWritesInLoops += 1;
       }
     }
   }
 #endif
   return Result;

lib/CodeGen/BlockGenerators.cpp

void BlockGenerator::generateScalarLoads(
   for (MemoryAccess *MA : Stmt) {
     if (MA->isOriginalArrayKind() || MA->isWrite())
       continue;
 
 #ifndef NDEBUG
     auto StmtDom =
         Stmt.getDomain().intersect_params(Stmt.getParent()->getContext());
     auto AccDom = MA->getAccessRelation().domain();
-    assert(!StmtDom.is_subset(AccDom).is_false() &&
+    assert(StmtDom.is_subset(AccDom, isl::quota::ret_true) &&
            "Scalar must be loaded in all statement instances");
 #endif
 
     auto *Address =
         getImplicitAddress(*MA, getLoopForStmt(Stmt), LTS, BBMap, NewAccesses);
     assert((!isa<Instruction>(Address) ||
             DT.dominates(cast<Instruction>(Address)->getParent(),
                          Builder.GetInsertBlock())) &&
            "Domination violation");
     BBMap[MA->getAccessValue()] =
         Builder.CreateLoad(Address, Address->getName() + ".reload");
   }
 }
 
 Value *BlockGenerator::buildContainsCondition(ScopStmt &Stmt,
                                               const isl::set &Subdomain) {
   isl::ast_build AstBuild = Stmt.getAstBuild();
   isl::set Domain = Stmt.getDomain();
 
   isl::union_map USchedule = AstBuild.get_schedule();
   USchedule = USchedule.intersect_domain(Domain);
 
-  assert(!USchedule.is_empty());
+  assert(!USchedule.is_empty(isl::quota::ret_false));
   isl::map Schedule = isl::map::from_union_map(USchedule);
 
   isl::set ScheduledDomain = Schedule.range();
   isl::set ScheduledSet = Subdomain.apply(Schedule);
 
   isl::ast_build RestrictedBuild = AstBuild.restrict(ScheduledDomain);
 
   isl::ast_expr IsInSet = RestrictedBuild.expr_from(ScheduledSet);
   Value *IsInSetExpr = ExprBuilder->create(IsInSet.copy());
   IsInSetExpr = Builder.CreateICmpNE(
       IsInSetExpr, ConstantInt::get(IsInSetExpr->getType(), 0));
 
   return IsInSetExpr;
 }
 
 void BlockGenerator::generateConditionalExecution(
     ScopStmt &Stmt, const isl::set &Subdomain, StringRef Subject,
     const std::function<void()> &GenThenFunc) {
   isl::set StmtDom = Stmt.getDomain();
 
   // If the condition is a tautology, don't generate a condition around the
   // code.
   bool IsPartialWrite =
       !StmtDom.intersect_params(Stmt.getParent()->getContext())
-           .is_subset(Subdomain);
+           .is_subset(Subdomain, isl::quota::unclear);
   if (!IsPartialWrite) {
     GenThenFunc();
     return;
   }
 
   // Generate the condition.
   Value *Cond = buildContainsCondition(Stmt, Subdomain);
 
void BlockGenerator::generateBeginStmtTrace(ScopStmt &Stmt, LoopToScevMapT &LTS,
   Scop *S = Stmt.getParent();
   const char *BaseName = Stmt.getBaseName();
 
   isl::ast_build AstBuild = Stmt.getAstBuild();
   isl::set Domain = Stmt.getDomain();
 
   isl::union_map USchedule = AstBuild.get_schedule().intersect_domain(Domain);
   isl::map Schedule = isl::map::from_union_map(USchedule);
-  assert(Schedule.is_empty().is_false() &&
+  assert(!Schedule.is_empty(isl::quota::ret_false) &&
          "The stmt must have a valid instance");
 
   isl::multi_pw_aff ScheduleMultiPwAff =
       isl::pw_multi_aff::from_map(Schedule.reverse());
   isl::ast_build RestrictedBuild = AstBuild.restrict(Schedule.range());
 
   // Sequence of strings to print.
   SmallVector<llvm::Value *, 8> Values;

lib/CodeGen/IslAst.cpp

static isl::ast_expr buildCondition(Scop &S, isl::ast_build Build,
 
   isl::ast_expr NonAliasGroup, MinExpr, MaxExpr;
 
   // In the following, we first check if any accesses will be empty under
   // the execution context of the scop and do not code generate them if this
   // is the case as isl will fail to derive valid AST expressions for such
   // accesses.
 
-  if (!AFirst.intersect_params(Params).domain().is_empty() &&
-      !BSecond.intersect_params(Params).domain().is_empty()) {
+  if (!AFirst.intersect_params(Params).domain().is_empty(isl::quota::unclear) &&
+      !BSecond.intersect_params(Params).domain().is_empty(
+          isl::quota::unclear)) {
     MinExpr = Build.access_from(AFirst).address_of();
     MaxExpr = Build.access_from(BSecond).address_of();
     NonAliasGroup = MaxExpr.le(MinExpr);
   }
 
-  if (!BFirst.intersect_params(Params).domain().is_empty() &&
-      !ASecond.intersect_params(Params).domain().is_empty()) {
+  if (!BFirst.intersect_params(Params).domain().is_empty(isl::quota::unclear) &&
+      !ASecond.intersect_params(Params).domain().is_empty(
+          isl::quota::unclear)) {
     MinExpr = Build.access_from(BFirst).address_of();
     MaxExpr = Build.access_from(ASecond).address_of();
 
     isl::ast_expr Result = MaxExpr.le(MinExpr);
     if (!NonAliasGroup.is_null())
       NonAliasGroup = isl::manage(
           isl_ast_expr_or(NonAliasGroup.release(), Result.release()));
     else

lib/CodeGen/IslNodeBuilder.cpp

#endif
     auto PWAccRel =
         MA->applyScheduleToAccessRelation(isl::manage(Schedule)).release();
 
     // isl cannot generate an index expression for access-nothing accesses.
     isl::set AccDomain =
         isl::manage(isl_pw_multi_aff_domain(isl_pw_multi_aff_copy(PWAccRel)));
     isl::set Context = S.getContext();
     AccDomain = AccDomain.intersect_params(Context);
-    if (AccDomain.is_empty()) {
+    if (AccDomain.is_empty(isl::quota::unclear)) {
       isl_pw_multi_aff_free(PWAccRel);
       continue;
     }
 
     auto AccessExpr = isl_ast_build_access_from_pw_multi_aff(Build, PWAccRel);
     NewAccesses =
         isl_id_to_ast_expr_set(NewAccesses, MA->getId().release(), AccessExpr);
   }

lib/CodeGen/PPCGCodeGeneration.cpp

Value *GPUNodeBuilder::getArrayOffset(gpu_array_info *Array) {
 
   isl::set Min = isl::manage_copy(Array->extent).lexmin();
 
   isl::set ZeroSet = isl::set::universe(Min.get_space());
 
   for (long i = 0, n = Min.dim(isl::dim::set); i < n; i++)
     ZeroSet = ZeroSet.fix_si(isl::dim::set, i, 0);
 
-  if (Min.is_subset(ZeroSet)) {
+  if (Min.is_subset(ZeroSet, isl::quota::unclear)) {
     return nullptr;
   }
 
   isl::ast_expr Result = isl::ast_expr::from_val(isl::val(Min.get_ctx(), 0));
 
   for (long i = 0, n = Min.dim(isl::dim::set); i < n; i++) {
     if (i > 0) {
       isl::pw_aff Bound_I =
if (Array->getNumberOfDimensions() == 0)
       return isl::set::universe(Array->getSpace());
 
     isl::union_map Accesses = S->getAccesses(Array);
     isl::union_set AccessUSet = Accesses.range();
     AccessUSet = AccessUSet.coalesce();
     AccessUSet = AccessUSet.detect_equalities();
     AccessUSet = AccessUSet.coalesce();
 
-    if (AccessUSet.is_empty())
+    if (AccessUSet.is_empty(isl::quota::unclear))
       return isl::set::empty(Array->getSpace());
 
     isl::set AccessSet = AccessUSet.extract_set(Array->getSpace());
 
     isl::local_space LS = isl::local_space(Array->getSpace());
 
     isl::pw_aff Val = isl::aff::var_on_domain(LS, isl::dim::set, 0);
     isl::pw_aff OuterMin = AccessSet.dim_min(0);
gpu_prog *createPPCGProg(ppcg_scop *PPCGScop) {
 
     // Only consider arrays that have a non-empty extent.
     // Otherwise, this will cause us to consider the following kinds of
     // empty arrays:
     //     1. Invariant loads that are represented by SAI objects.
     //     2. Arrays with statically known zero size.
     auto ValidSAIsRange =
         make_filter_range(S->arrays(), [this](ScopArrayInfo *SAI) -> bool {
-          return !getExtent(SAI).is_empty();
+          return !getExtent(SAI).is_empty(isl::quota::unclear);
         });
     SmallVector<ScopArrayInfo *, 4> ValidSAIs(ValidSAIsRange.begin(),
                                               ValidSAIsRange.end());
 
     PPCGProg->n_array =
         ValidSAIs.size(); // std::distance(S->array_begin(), S->array_end());
     PPCGProg->array = isl_calloc_array(
         S->getIslCtx().get(), struct gpu_array_info, PPCGProg->n_array);

lib/Exchange/JSONExporter.cpp

static bool importContext(Scop &S, Json::Value &JScop) {
 
   // Check whether the context was parsed successfully.
   if (!NewContext) {
     errs() << "The context was not parsed successfully by ISL.\n";
     return false;
   }
 
   // Check if the isl_set is a parameter set.
-  if (!NewContext.is_params()) {
+  if (!NewContext.is_params(isl::quota::unclear)) {
     errs() << "The isl_set is not a parameter set.\n";
     return false;
   }
 
   unsigned OldContextDim = OldContext.dim(isl::dim::param);
   unsigned NewContextDim = NewContext.dim(isl::dim::param);
 
   // Check if the imported context has the right number of parameters.

lib/External/isl/include/isl/isl-noexceptions.h

 #include <isl/mat.h>
 
 #include <functional>
 #include <string>
 
 namespace isl {
 inline namespace noexceptions {
 
-#define ISLPP_STRINGIZE_(X) #X
-#define ISLPP_STRINGIZE(X) ISLPP_STRINGIZE_(X)
-
-#define ISLPP_ASSERT(test, message)                          \
-  do {                                                       \
-    if (test)                                                \
-      break;                                                 \
-    fputs("Assertion \"" #test "\" failed at " __FILE__      \
-      ":" ISLPP_STRINGIZE(__LINE__) "\n  " message "\n",     \
-      stderr);                                               \
-    abort();                                                 \
-  } while (0)
-
-class boolean {
-private:
-  isl_bool val;
-
-  friend isl::boolean manage(isl_bool val);
-  boolean(isl_bool val): val(val) {}
-public:
-  boolean()
-      : val(isl_bool_error) {}
-
-  /* implicit */ boolean(bool val)
-      : val(val ? isl_bool_true : isl_bool_false) {}
-
-  bool is_error() const { return val == isl_bool_error; }
-  bool is_false() const { return val == isl_bool_false; }
-  bool is_true() const { return val == isl_bool_true; }
-
-  operator bool() const {
-    ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
-    return is_true();
-  }
-
-  boolean operator!() const {
-    if (is_error())
-      return *this;
-    return !is_true();
-  }
-};
-
-inline isl::boolean manage(isl_bool val) {
-  return isl::boolean(val);
-}
-
 class ctx {
   isl_ctx *ptr;
 public:
   /* implicit */ ctx(isl_ctx *ctx)
       : ptr(ctx) {}
   isl_ctx *release() {
     auto tmp = ptr;
     ptr = nullptr;
     return tmp;
   }
   isl_ctx *get() {
     return ptr;
   }
 };
 
-enum class stat {
-  ok = isl_stat_ok,
-  error = isl_stat_error
+template<typename T>
+class quota_ignore;
+template<typename T>
+class quota_true;
+template<typename T>
+class quota_false;
+template<typename T>
+class quota_unclear;
+
+/* Interface of an error handler which is called in case of a quota error.
+ */
+template<typename T>
+class quotaBase {
+public:
+  static quota_ignore<T> ignore;
+  static quota_true<T> ret_true;
+  static quota_false<T> ret_false;
+  static quota_unclear<T> unclear;
+
+  virtual ~quotaBase() = default;
+
+  /* Report an error for a function with return type 'bool'.
+   *
+   * The value returned by this function is forwarded as return value of the
+   * function triggering the error.
+   */
+  virtual bool report_bool() = 0;
+};
+
+/* Indicate that when a quota-error occurs, the value that is returned
+ * by the function triggering the error is ignored.
+ */
+template<typename T>
+class quota_ignore : public quotaBase<T> {
+public:
+  virtual bool report_bool() override { return true; }
+};
+
+/* Indicate that when a quota-error occurs, the value that is returned
+ * by the function triggering the error is "true".
+ */
+template<typename T>
+class quota_true : public quotaBase<T> {
+public:
+  virtual bool report_bool() override { return true; }
 };
 
+/* Indicate that when a quota-error occurs, the value that is returned
+ * by the function triggering the error is "false".
+ */
+template<typename T>
+class quota_false : public quotaBase<T> {
+public:
+  virtual bool report_bool() override { return false; }
+};
+
+/* Indicate that when a quota-error occurs, that I did not yet think about
+ * this.
+ */
+template<typename T>
+class quota_unclear : public quotaBase<T> {
+public:
+  virtual bool report_bool() override { return false; }
+};
+
+template<typename T>
+quota_ignore<T> quotaBase<T>::ignore;
+template<typename T>
+quota_true<T> quotaBase<T>::ret_true;
+template<typename T>
+quota_false<T> quotaBase<T>::ret_false;
+template<typename T>
+quota_unclear<T> quotaBase<T>::unclear;
+
+using quota = quotaBase<void>;
+
 enum class dim {
   cst = isl_dim_cst,
   param = isl_dim_param,
   in = isl_dim_in,
   out = isl_dim_out,
   set = isl_dim_set,
   div = isl_dim_div,
   all = isl_dim_all
public:
   inline uint32_t get_hash() const;
   inline isl::local_space get_local_space() const;
   inline isl::space get_space() const;
   inline isl::aff gist(isl::set context) const;
   inline isl::aff gist_params(isl::set context) const;
   inline isl::basic_set gt_basic_set(isl::aff aff2) const;
   inline isl::set gt_set(isl::aff aff2) const;
   inline isl::aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_cst() const;
-  inline isl::boolean is_nan() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_cst(isl::quota &quota) const;
+  inline bool is_nan(isl::quota &quota) const;
   inline isl::basic_set le_basic_set(isl::aff aff2) const;
   inline isl::set le_set(isl::aff aff2) const;
   inline isl::basic_set lt_basic_set(isl::aff aff2) const;
   inline isl::set lt_set(isl::aff aff2) const;
   inline isl::aff mod(isl::val mod) const;
   inline isl::aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline isl::aff mul(isl::aff aff2) const;
   static inline isl::aff nan_on_domain(isl::local_space ls);
   inline isl::set ne_set(isl::aff aff2) const;
   inline isl::aff neg() const;
   inline isl::basic_set neg_basic_set() const;
   static inline isl::aff param_on_domain_space_id(isl::space space, isl::id id);
-  inline isl::boolean plain_is_equal(const isl::aff &aff2) const;
-  inline isl::boolean plain_is_zero() const;
+  inline bool plain_is_equal(const isl::aff &aff2, isl::quota &quota) const;
+  inline bool plain_is_zero(isl::quota &quota) const;
   inline isl::aff project_domain_on_params() const;
   inline isl::aff pullback(isl::multi_aff ma) const;
   inline isl::aff pullback_aff(isl::aff aff2) const;
   inline isl::aff scale(isl::val v) const;
   inline isl::aff scale_down(isl::val v) const;
   inline isl::aff scale_down_ui(unsigned int f) const;
   inline isl::aff set_coefficient_si(isl::dim type, int pos, int v) const;
   inline isl::aff set_coefficient_val(isl::dim type, int pos, isl::val v) const;
public:
   static inline isl::ast_expr from_id(isl::id id);
   static inline isl::ast_expr from_val(isl::val v);
   inline isl::ast_expr ge(isl::ast_expr expr2) const;
   inline isl::id get_id() const;
   inline isl::ast_expr get_op_arg(int pos) const;
   inline int get_op_n_arg() const;
   inline isl::val get_val() const;
   inline isl::ast_expr gt(isl::ast_expr expr2) const;
-  inline isl::boolean is_equal(const isl::ast_expr &expr2) const;
+  inline bool is_equal(const isl::ast_expr &expr2, isl::quota &quota) const;
   inline isl::ast_expr le(isl::ast_expr expr2) const;
   inline isl::ast_expr lt(isl::ast_expr expr2) const;
   inline isl::ast_expr mul(isl::ast_expr expr2) const;
   inline isl::ast_expr neg() const;
   inline isl::ast_expr pdiv_q(isl::ast_expr expr2) const;
   inline isl::ast_expr pdiv_r(isl::ast_expr expr2) const;
   inline isl::ast_expr set_op_arg(int pos, isl::ast_expr arg) const;
   inline isl::ast_expr sub(isl::ast_expr expr2) const;
public:
 
   static inline isl::ast_node alloc_user(isl::ast_expr expr);
   inline isl::ast_node_list block_get_children() const;
   inline isl::ast_node for_get_body() const;
   inline isl::ast_expr for_get_cond() const;
   inline isl::ast_expr for_get_inc() const;
   inline isl::ast_expr for_get_init() const;
   inline isl::ast_expr for_get_iterator() const;
-  inline isl::boolean for_is_degenerate() const;
+  inline bool for_is_degenerate(isl::quota &quota) const;
   inline isl::id get_annotation() const;
   inline isl::ast_expr if_get_cond() const;
   inline isl::ast_node if_get_else() const;
   inline isl::ast_node if_get_then() const;
-  inline isl::boolean if_has_else() const;
+  inline bool if_has_else(isl::quota &quota) const;
   inline isl::id mark_get_id() const;
   inline isl::ast_node mark_get_node() const;
   inline isl::ast_node set_annotation(isl::id annotation) const;
   inline std::string to_C_str() const;
   inline isl::ast_expr user_get_expr() const;
 };
 
 // declarations for isl::ast_node_list
public:
   inline void dump() const;
 
   inline isl::basic_map add_constraint(isl::constraint constraint) const;
   inline isl::basic_map add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_map affine_hull() const;
   inline isl::basic_map align_params(isl::space model) const;
   inline isl::basic_map apply_domain(isl::basic_map bmap2) const;
   inline isl::basic_map apply_range(isl::basic_map bmap2) const;
-  inline isl::boolean can_curry() const;
-  inline isl::boolean can_uncurry() const;
-  inline isl::boolean can_zip() const;
+  inline bool can_curry(isl::quota &quota) const;
+  inline bool can_uncurry(isl::quota &quota) const;
+  inline bool can_zip(isl::quota &quota) const;
   inline isl::basic_map curry() const;
   inline isl::basic_set deltas() const;
   inline isl::basic_map deltas_map() const;
   inline isl::basic_map detect_equalities() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::basic_set domain() const;
   inline isl::basic_map domain_map() const;
   inline isl::basic_map domain_product(isl::basic_map bmap2) const;
   inline isl::basic_map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_map drop_unused_params() const;
   inline isl::basic_map eliminate(isl::dim type, unsigned int first, unsigned int n) const;
   static inline isl::basic_map empty(isl::space space);
   static inline isl::basic_map equal(isl::space dim, unsigned int n_equal);
   inline isl::basic_map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::basic_map fix_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::basic_map fix_val(isl::dim type, unsigned int pos, isl::val v) const;
   inline isl::basic_map flat_product(isl::basic_map bmap2) const;
   inline isl::basic_map flat_range_product(isl::basic_map bmap2) const;
   inline isl::basic_map flatten() const;
   inline isl::basic_map flatten_domain() const;
   inline isl::basic_map flatten_range() const;
-  inline isl::stat foreach_constraint(const std::function<isl::stat(isl::constraint)> &fn) const;
+  inline void foreach_constraint(const std::function<void(isl::constraint)> &fn) const;
   static inline isl::basic_map from_aff(isl::aff aff);
   static inline isl::basic_map from_aff_list(isl::space domain_dim, isl::aff_list list);
   static inline isl::basic_map from_constraint(isl::constraint constraint);
   static inline isl::basic_map from_domain(isl::basic_set bset);
   static inline isl::basic_map from_domain_and_range(isl::basic_set domain, isl::basic_set range);
   static inline isl::basic_map from_multi_aff(isl::multi_aff maff);
   static inline isl::basic_map from_qpolynomial(isl::qpolynomial qp);
   static inline isl::basic_map from_range(isl::basic_set bset);
   inline isl::constraint_list get_constraint_list() const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::aff get_div(int pos) const;
   inline isl::local_space get_local_space() const;
   inline isl::space get_space() const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::basic_map gist(isl::basic_map context) const;
   inline isl::basic_map gist_domain(isl::basic_set context) const;
-  inline isl::boolean has_dim_id(isl::dim type, unsigned int pos) const;
+  inline bool has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const;
   static inline isl::basic_map identity(isl::space dim);
-  inline isl::boolean image_is_bounded() const;
+  inline bool image_is_bounded(isl::quota &quota) const;
   inline isl::basic_map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
   inline isl::basic_map intersect(isl::basic_map bmap2) const;
   inline isl::basic_map intersect_domain(isl::basic_set bset) const;
   inline isl::basic_map intersect_range(isl::basic_set bset) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_disjoint(const isl::basic_map &bmap2) const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::basic_map &bmap2) const;
-  inline isl::boolean is_rational() const;
-  inline isl::boolean is_single_valued() const;
-  inline isl::boolean is_strict_subset(const isl::basic_map &bmap2) const;
-  inline isl::boolean is_subset(const isl::basic_map &bmap2) const;
-  inline isl::boolean is_universe() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_disjoint(const isl::basic_map &bmap2, isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::basic_map &bmap2, isl::quota &quota) const;
+  inline bool is_rational(isl::quota &quota) const;
+  inline bool is_single_valued(isl::quota &quota) const;
+  inline bool is_strict_subset(const isl::basic_map &bmap2, isl::quota &quota) const;
+  inline bool is_subset(const isl::basic_map &bmap2, isl::quota &quota) const;
+  inline bool is_universe(isl::quota &quota) const;
   static inline isl::basic_map less_at(isl::space dim, unsigned int pos);
   inline isl::map lexmax() const;
   inline isl::map lexmin() const;
   inline isl::pw_multi_aff lexmin_pw_multi_aff() const;
   inline isl::basic_map lower_bound_si(isl::dim type, unsigned int pos, int value) const;
   static inline isl::basic_map more_at(isl::space dim, unsigned int pos);
   inline isl::basic_map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline int n_constraint() const;
   static inline isl::basic_map nat_universe(isl::space dim);
   inline isl::basic_map neg() const;
   inline isl::basic_map order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::basic_map order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
-  inline isl::boolean plain_is_empty() const;
-  inline isl::boolean plain_is_universe() const;
+  inline bool plain_is_empty(isl::quota &quota) const;
+  inline bool plain_is_universe(isl::quota &quota) const;
   inline isl::basic_map preimage_domain_multi_aff(isl::multi_aff ma) const;
   inline isl::basic_map preimage_range_multi_aff(isl::multi_aff ma) const;
   inline isl::basic_map product(isl::basic_map bmap2) const;
   inline isl::basic_map project_out(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_set range() const;
   inline isl::basic_map range_map() const;
   inline isl::basic_map range_product(isl::basic_map bmap2) const;
   inline isl::basic_map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline isl::basic_set drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_set drop_unused_params() const;
   inline isl::basic_set eliminate(isl::dim type, unsigned int first, unsigned int n) const;
   static inline isl::basic_set empty(isl::space space);
   inline isl::basic_set fix_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::basic_set fix_val(isl::dim type, unsigned int pos, isl::val v) const;
   inline isl::basic_set flat_product(isl::basic_set bset2) const;
   inline isl::basic_set flatten() const;
-  inline isl::stat foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<isl::stat(isl::constraint, isl::constraint, isl::basic_set)> &fn) const;
-  inline isl::stat foreach_constraint(const std::function<isl::stat(isl::constraint)> &fn) const;
+  inline void foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<void(isl::constraint, isl::constraint, isl::basic_set)> &fn) const;
+  inline void foreach_constraint(const std::function<void(isl::constraint)> &fn) const;
   static inline isl::basic_set from_constraint(isl::constraint constraint);
   inline isl::basic_set from_params() const;
   inline isl::constraint_list get_constraint_list() const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::aff get_div(int pos) const;
   inline isl::local_space get_local_space() const;
   inline isl::space get_space() const;
   inline std::string get_tuple_name() const;
   inline isl::basic_set gist(isl::basic_set context) const;
   inline isl::basic_set insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
   inline isl::basic_set intersect(isl::basic_set bset2) const;
   inline isl::basic_set intersect_params(isl::basic_set bset2) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_bounded() const;
-  inline isl::boolean is_disjoint(const isl::basic_set &bset2) const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::basic_set &bset2) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_bounded(isl::quota &quota) const;
+  inline bool is_disjoint(const isl::basic_set &bset2, isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::basic_set &bset2, isl::quota &quota) const;
   inline int is_rational() const;
-  inline isl::boolean is_subset(const isl::basic_set &bset2) const;
-  inline isl::boolean is_universe() const;
-  inline isl::boolean is_wrapping() const;
+  inline bool is_subset(const isl::basic_set &bset2, isl::quota &quota) const;
+  inline bool is_universe(isl::quota &quota) const;
+  inline bool is_wrapping(isl::quota &quota) const;
   inline isl::set lexmax() const;
   inline isl::set lexmin() const;
   inline isl::basic_set lower_bound_val(isl::dim type, unsigned int pos, isl::val value) const;
   inline isl::val max_val(const isl::aff &obj) const;
   inline isl::basic_set move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline int n_constraint() const;
   inline unsigned int n_dim() const;
   static inline isl::basic_set nat_universe(isl::space dim);
   inline isl::basic_set neg() const;
   inline isl::basic_set params() const;
-  inline isl::boolean plain_is_empty() const;
-  inline isl::boolean plain_is_equal(const isl::basic_set &bset2) const;
-  inline isl::boolean plain_is_universe() const;
+  inline bool plain_is_empty(isl::quota &quota) const;
+  inline bool plain_is_equal(const isl::basic_set &bset2, isl::quota &quota) const;
+  inline bool plain_is_universe(isl::quota &quota) const;
   static inline isl::basic_set positive_orthant(isl::space space);
   inline isl::basic_set preimage_multi_aff(isl::multi_aff ma) const;
   inline isl::basic_set project_out(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_set remove_divs() const;
   inline isl::basic_set remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::basic_set remove_redundancies() const;
   inline isl::basic_set remove_unknown_divs() const;
public:
   inline isl::aff get_aff() const;
   inline isl::aff get_bound(isl::dim type, int pos) const;
   inline isl::val get_coefficient_val(isl::dim type, int pos) const;
   inline isl::val get_constant_val() const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::aff get_div(int pos) const;
   inline isl::local_space get_local_space() const;
   inline isl::space get_space() const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
   inline int is_div_constraint() const;
-  inline isl::boolean is_lower_bound(isl::dim type, unsigned int pos) const;
-  inline isl::boolean is_upper_bound(isl::dim type, unsigned int pos) const;
+  inline bool is_lower_bound(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool is_upper_bound(isl::dim type, unsigned int pos, isl::quota &quota) const;
   inline int plain_cmp(const isl::constraint &c2) const;
   inline isl::constraint set_coefficient_si(isl::dim type, int pos, int v) const;
   inline isl::constraint set_coefficient_val(isl::dim type, int pos, isl::val v) const;
   inline isl::constraint set_constant_si(int v) const;
   inline isl::constraint set_constant_val(isl::val v) const;
 };
 
 // declarations for isl::constraint_list
public:
   inline __isl_give isl_id_to_ast_expr *release();
   inline bool is_null() const;
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline void dump() const;
 
   static inline isl::id_to_ast_expr alloc(isl::ctx ctx, int min_size);
   inline isl::id_to_ast_expr drop(isl::id key) const;
-  inline isl::stat foreach(const std::function<isl::stat(isl::id, isl::ast_expr)> &fn) const;
+  inline void foreach(const std::function<void(isl::id, isl::ast_expr)> &fn) const;
   inline isl::ast_expr get(isl::id key) const;
-  inline isl::boolean has(const isl::id &key) const;
+  inline bool has(const isl::id &key, isl::quota &quota) const;
   inline isl::id_to_ast_expr set(isl::id key, isl::ast_expr val) const;
 };
 
 // declarations for isl::local_space
 inline isl::local_space manage(__isl_take isl_local_space *ptr);
 inline isl::local_space manage_copy(__isl_keep isl_local_space *ptr);
 
 class local_space {
public:
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::local_space flatten_domain() const;
   inline isl::local_space flatten_range() const;
   inline isl::local_space from_domain() const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::aff get_div(int pos) const;
   inline isl::space get_space() const;
-  inline isl::boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_dim_name(isl::dim type, unsigned int pos) const;
+  inline bool has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const;
   inline isl::local_space insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::local_space intersect(isl::local_space ls2) const;
-  inline isl::boolean is_equal(const isl::local_space &ls2) const;
-  inline isl::boolean is_params() const;
-  inline isl::boolean is_set() const;
+  inline bool is_equal(const isl::local_space &ls2, isl::quota &quota) const;
+  inline bool is_params(isl::quota &quota) const;
+  inline bool is_set(isl::quota &quota) const;
   inline isl::local_space range() const;
   inline isl::local_space set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
   inline isl::local_space set_from_params() const;
   inline isl::local_space set_tuple_id(isl::dim type, isl::id id) const;
   inline isl::local_space wrap() const;
 };
 
 // declarations for isl::map
public:
   inline void dump() const;
 
   inline isl::map add_constraint(isl::constraint constraint) const;
   inline isl::map add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_map affine_hull() const;
   inline isl::map align_params(isl::space model) const;
   inline isl::map apply_domain(isl::map map2) const;
   inline isl::map apply_range(isl::map map2) const;
-  inline isl::boolean can_curry() const;
-  inline isl::boolean can_range_curry() const;
-  inline isl::boolean can_uncurry() const;
-  inline isl::boolean can_zip() const;
+  inline bool can_curry(isl::quota &quota) const;
+  inline bool can_range_curry(isl::quota &quota) const;
+  inline bool can_uncurry(isl::quota &quota) const;
+  inline bool can_zip(isl::quota &quota) const;
   inline isl::map coalesce() const;
   inline isl::map complement() const;
   inline isl::basic_map convex_hull() const;
   inline isl::map curry() const;
   inline isl::set deltas() const;
   inline isl::map deltas_map() const;
   inline isl::map detect_equalities() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::pw_aff dim_max(int pos) const;
   inline isl::pw_aff dim_min(int pos) const;
   inline isl::set domain() const;
   inline isl::map domain_factor_domain() const;
   inline isl::map domain_factor_range() const;
-  inline isl::boolean domain_is_wrapping() const;
+  inline bool domain_is_wrapping(isl::quota &quota) const;
   inline isl::map domain_map() const;
   inline isl::map domain_product(isl::map map2) const;
   inline isl::map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::map drop_unused_params() const;
   inline isl::map eliminate(isl::dim type, unsigned int first, unsigned int n) const;
   static inline isl::map empty(isl::space space);
   inline isl::map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::map factor_domain() const;
   inline isl::map factor_range() const;
   inline int find_dim_by_id(isl::dim type, const isl::id &id) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::map fix_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::map fix_val(isl::dim type, unsigned int pos, isl::val v) const;
   inline isl::map fixed_power_val(isl::val exp) const;
   inline isl::map flat_domain_product(isl::map map2) const;
   inline isl::map flat_product(isl::map map2) const;
   inline isl::map flat_range_product(isl::map map2) const;
   inline isl::map flatten() const;
   inline isl::map flatten_domain() const;
   inline isl::map flatten_range() const;
   inline isl::map floordiv_val(isl::val d) const;
-  inline isl::stat foreach_basic_map(const std::function<isl::stat(isl::basic_map)> &fn) const;
+  inline void foreach_basic_map(const std::function<void(isl::basic_map)> &fn) const;
   static inline isl::map from_aff(isl::aff aff);
   static inline isl::map from_domain(isl::set set);
   static inline isl::map from_domain_and_range(isl::set domain, isl::set range);
   static inline isl::map from_multi_aff(isl::multi_aff maff);
   static inline isl::map from_multi_pw_aff(isl::multi_pw_aff mpa);
   static inline isl::map from_pw_aff(isl::pw_aff pwaff);
   static inline isl::map from_pw_multi_aff(isl::pw_multi_aff pma);
   static inline isl::map from_range(isl::set set);
   static inline isl::map from_union_map(isl::union_map umap);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline uint32_t get_hash() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::map gist(isl::map context) const;
   inline isl::map gist_basic_map(isl::basic_map context) const;
   inline isl::map gist_domain(isl::set context) const;
   inline isl::map gist_params(isl::set context) const;
   inline isl::map gist_range(isl::set context) const;
-  inline isl::boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_dim_name(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_equal_space(const isl::map &map2) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
-  inline isl::boolean has_tuple_name(isl::dim type) const;
+  inline bool has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_equal_space(const isl::map &map2, isl::quota &quota) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
+  inline bool has_tuple_name(isl::dim type, isl::quota &quota) const;
   static inline isl::map identity(isl::space dim);
   inline isl::map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
   inline isl::map intersect(isl::map map2) const;
   inline isl::map intersect_domain(isl::set set) const;
   inline isl::map intersect_domain_factor_range(isl::map factor) const;
   inline isl::map intersect_params(isl::set params) const;
   inline isl::map intersect_range(isl::set set) const;
   inline isl::map intersect_range_factor_range(isl::map factor) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_bijective() const;
-  inline isl::boolean is_disjoint(const isl::map &map2) const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::map &map2) const;
-  inline isl::boolean is_identity() const;
-  inline isl::boolean is_injective() const;
-  inline isl::boolean is_product() const;
-  inline isl::boolean is_single_valued() const;
-  inline isl::boolean is_strict_subset(const isl::map &map2) const;
-  inline isl::boolean is_subset(const isl::map &map2) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_bijective(isl::quota &quota) const;
+  inline bool is_disjoint(const isl::map &map2, isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::map &map2, isl::quota &quota) const;
+  inline bool is_identity(isl::quota &quota) const;
+  inline bool is_injective(isl::quota &quota) const;
+  inline bool is_product(isl::quota &quota) const;
+  inline bool is_single_valued(isl::quota &quota) const;
+  inline bool is_strict_subset(const isl::map &map2, isl::quota &quota) const;
+  inline bool is_subset(const isl::map &map2, isl::quota &quota) const;
   inline int is_translation() const;
   static inline isl::map lex_ge(isl::space set_dim);
   static inline isl::map lex_ge_first(isl::space dim, unsigned int n);
   inline isl::map lex_ge_map(isl::map map2) const;
   static inline isl::map lex_gt(isl::space set_dim);
   static inline isl::map lex_gt_first(isl::space dim, unsigned int n);
   inline isl::map lex_gt_map(isl::map map2) const;
   static inline isl::map lex_le(isl::space set_dim);
public:
   inline isl::map neg() const;
   inline isl::map oppose(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::map order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::map order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::map order_le(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::map order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline isl::set params() const;
   inline isl::val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
-  inline isl::boolean plain_is_empty() const;
-  inline isl::boolean plain_is_equal(const isl::map &map2) const;
-  inline isl::boolean plain_is_injective() const;
-  inline isl::boolean plain_is_single_valued() const;
-  inline isl::boolean plain_is_universe() const;
+  inline bool plain_is_empty(isl::quota &quota) const;
+  inline bool plain_is_equal(const isl::map &map2, isl::quota &quota) const;
+  inline bool plain_is_injective(isl::quota &quota) const;
+  inline bool plain_is_single_valued(isl::quota &quota) const;
+  inline bool plain_is_universe(isl::quota &quota) const;
   inline isl::basic_map plain_unshifted_simple_hull() const;
   inline isl::basic_map polyhedral_hull() const;
   inline isl::map preimage_domain_multi_aff(isl::multi_aff ma) const;
   inline isl::map preimage_domain_multi_pw_aff(isl::multi_pw_aff mpa) const;
   inline isl::map preimage_domain_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::map preimage_range_multi_aff(isl::multi_aff ma) const;
   inline isl::map preimage_range_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::map product(isl::map map2) const;
   inline isl::map project_out(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set range() const;
   inline isl::map range_curry() const;
   inline isl::map range_factor_domain() const;
   inline isl::map range_factor_range() const;
-  inline isl::boolean range_is_wrapping() const;
+  inline bool range_is_wrapping(isl::quota &quota) const;
   inline isl::map range_map() const;
   inline isl::map range_product(isl::map map2) const;
   inline isl::map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::map remove_divs() const;
   inline isl::map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::map remove_redundancies() const;
   inline isl::map remove_unknown_divs() const;
   inline isl::map reset_tuple_id(isl::dim type) const;
public:
   static inline isl::mat alloc(isl::ctx ctx, unsigned int n_row, unsigned int n_col);
   inline int cols() const;
   inline isl::mat concat(isl::mat bot) const;
   inline isl::mat diagonal(isl::mat mat2) const;
   inline isl::mat drop_cols(unsigned int col, unsigned int n) const;
   inline isl::mat drop_rows(unsigned int row, unsigned int n) const;
   static inline isl::mat from_row_vec(isl::vec vec);
   inline isl::val get_element_val(int row, int col) const;
-  inline isl::boolean has_linearly_independent_rows(const isl::mat &mat2) const;
+  inline bool has_linearly_independent_rows(const isl::mat &mat2, isl::quota &quota) const;
   inline int initial_non_zero_cols() const;
   inline isl::mat insert_cols(unsigned int col, unsigned int n) const;
   inline isl::mat insert_rows(unsigned int row, unsigned int n) const;
   inline isl::mat insert_zero_cols(unsigned int first, unsigned int n) const;
   inline isl::mat insert_zero_rows(unsigned int row, unsigned int n) const;
   inline isl::mat inverse_product(isl::mat right) const;
-  inline isl::boolean is_equal(const isl::mat &mat2) const;
+  inline bool is_equal(const isl::mat &mat2, isl::quota &quota) const;
   inline isl::mat lin_to_aff() const;
   inline isl::mat move_cols(unsigned int dst_col, unsigned int src_col, unsigned int n) const;
   inline isl::mat normalize() const;
   inline isl::mat normalize_row(int row) const;
   inline isl::mat product(isl::mat right) const;
   inline int rank() const;
   inline isl::mat right_inverse() const;
   inline isl::mat right_kernel() const;
public:
   inline isl::aff get_aff(int pos) const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::multi_aff gist(isl::set context) const;
   inline isl::multi_aff gist_params(isl::set context) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
   static inline isl::multi_aff identity(isl::space space);
   inline isl::multi_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_nan() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool involves_nan(isl::quota &quota) const;
   inline isl::set lex_ge_set(isl::multi_aff ma2) const;
   inline isl::set lex_gt_set(isl::multi_aff ma2) const;
   inline isl::set lex_le_set(isl::multi_aff ma2) const;
   inline isl::set lex_lt_set(isl::multi_aff ma2) const;
   inline isl::multi_aff mod_multi_val(isl::multi_val mv) const;
   inline isl::multi_aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   static inline isl::multi_aff multi_val_on_space(isl::space space, isl::multi_val mv);
   inline isl::multi_aff neg() const;
   inline int plain_cmp(const isl::multi_aff &multi2) const;
-  inline isl::boolean plain_is_equal(const isl::multi_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_aff &multi2, isl::quota &quota) const;
   inline isl::multi_aff product(isl::multi_aff multi2) const;
   inline isl::multi_aff project_domain_on_params() const;
   static inline isl::multi_aff project_out_map(isl::space space, isl::dim type, unsigned int first, unsigned int n);
   inline isl::multi_aff pullback(isl::multi_aff ma2) const;
   inline isl::multi_aff range_factor_domain() const;
   inline isl::multi_aff range_factor_range() const;
-  inline isl::boolean range_is_wrapping() const;
+  inline bool range_is_wrapping(isl::quota &quota) const;
   static inline isl::multi_aff range_map(isl::space space);
   inline isl::multi_aff range_product(isl::multi_aff multi2) const;
   inline isl::multi_aff range_splice(unsigned int pos, isl::multi_aff multi2) const;
   inline isl::multi_aff reset_tuple_id(isl::dim type) const;
   inline isl::multi_aff reset_user() const;
   inline isl::multi_aff scale_down_multi_val(isl::multi_val mv) const;
   inline isl::multi_aff scale_down_val(isl::val v) const;
   inline isl::multi_aff scale_multi_val(isl::multi_val mv) const;
public:
   inline isl::space get_domain_space() const;
   inline uint32_t get_hash() const;
   inline isl::pw_aff get_pw_aff(int pos) const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::multi_pw_aff gist(isl::set set) const;
   inline isl::multi_pw_aff gist_params(isl::set set) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
   static inline isl::multi_pw_aff identity(isl::space space);
   inline isl::multi_pw_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::multi_pw_aff intersect_domain(isl::set domain) const;
   inline isl::multi_pw_aff intersect_params(isl::set set) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_nan() const;
-  inline isl::boolean is_cst() const;
-  inline isl::boolean is_equal(const isl::multi_pw_aff &mpa2) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool involves_nan(isl::quota &quota) const;
+  inline bool is_cst(isl::quota &quota) const;
+  inline bool is_equal(const isl::multi_pw_aff &mpa2, isl::quota &quota) const;
   inline isl::map lex_gt_map(isl::multi_pw_aff mpa2) const;
   inline isl::map lex_lt_map(isl::multi_pw_aff mpa2) const;
   inline isl::multi_pw_aff mod_multi_val(isl::multi_val mv) const;
   inline isl::multi_pw_aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline isl::multi_pw_aff neg() const;
-  inline isl::boolean plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_pw_aff &multi2, isl::quota &quota) const;
   inline isl::multi_pw_aff product(isl::multi_pw_aff multi2) const;
   inline isl::multi_pw_aff project_domain_on_params() const;
   inline isl::multi_pw_aff pullback(isl::multi_aff ma) const;
   inline isl::multi_pw_aff pullback(isl::pw_multi_aff pma) const;
   inline isl::multi_pw_aff pullback(isl::multi_pw_aff mpa2) const;
   inline isl::multi_pw_aff range_factor_domain() const;
   inline isl::multi_pw_aff range_factor_range() const;
-  inline isl::boolean range_is_wrapping() const;
+  inline bool range_is_wrapping(isl::quota &quota) const;
   inline isl::multi_pw_aff range_product(isl::multi_pw_aff multi2) const;
   inline isl::multi_pw_aff range_splice(unsigned int pos, isl::multi_pw_aff multi2) const;
   inline isl::multi_pw_aff reset_tuple_id(isl::dim type) const;
   inline isl::multi_pw_aff reset_user() const;
   inline isl::multi_pw_aff scale_down_multi_val(isl::multi_val mv) const;
   inline isl::multi_pw_aff scale_down_val(isl::val v) const;
   inline isl::multi_pw_aff scale_multi_val(isl::multi_val mv) const;
   inline isl::multi_pw_aff scale_val(isl::val v) const;
public:
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::union_pw_aff get_union_pw_aff(int pos) const;
   inline isl::multi_union_pw_aff gist(isl::union_set context) const;
   inline isl::multi_union_pw_aff gist_params(isl::set context) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
   inline isl::multi_union_pw_aff intersect_domain(isl::union_set uset) const;
   inline isl::multi_union_pw_aff intersect_params(isl::set params) const;
   inline isl::multi_union_pw_aff intersect_range(isl::set set) const;
-  inline isl::boolean involves_nan() const;
+  inline bool involves_nan(isl::quota &quota) const;
   inline isl::multi_union_pw_aff mod_multi_val(isl::multi_val mv) const;
   static inline isl::multi_union_pw_aff multi_aff_on_domain(isl::union_set domain, isl::multi_aff ma);
   static inline isl::multi_union_pw_aff multi_val_on_domain(isl::union_set domain, isl::multi_val mv);
   inline isl::multi_union_pw_aff neg() const;
-  inline isl::boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_union_pw_aff &multi2, isl::quota &quota) const;
   inline isl::multi_union_pw_aff pullback(isl::union_pw_multi_aff upma) const;
   static inline isl::multi_union_pw_aff pw_multi_aff_on_domain(isl::union_set domain, isl::pw_multi_aff pma);
   inline isl::multi_union_pw_aff range_factor_domain() const;
   inline isl::multi_union_pw_aff range_factor_range() const;
-  inline isl::boolean range_is_wrapping() const;
+  inline bool range_is_wrapping(isl::quota &quota) const;
   inline isl::multi_union_pw_aff range_product(isl::multi_union_pw_aff multi2) const;
   inline isl::multi_union_pw_aff range_splice(unsigned int pos, isl::multi_union_pw_aff multi2) const;
   inline isl::multi_union_pw_aff reset_tuple_id(isl::dim type) const;
   inline isl::multi_union_pw_aff reset_user() const;
   inline isl::multi_union_pw_aff scale_down_multi_val(isl::multi_val mv) const;
   inline isl::multi_union_pw_aff scale_down_val(isl::val v) const;
   inline isl::multi_union_pw_aff scale_multi_val(isl::multi_val mv) const;
   inline isl::multi_union_pw_aff scale_val(isl::val v) const;
public:
   inline isl::multi_val from_range() const;
   static inline isl::multi_val from_val_list(isl::space space, isl::val_list list);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::val get_val(int pos) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
   inline isl::multi_val insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_nan() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool involves_nan(isl::quota &quota) const;
   inline isl::multi_val mod_multi_val(isl::multi_val mv) const;
   inline isl::multi_val mod_val(isl::val v) const;
   inline isl::multi_val neg() const;
-  inline isl::boolean plain_is_equal(const isl::multi_val &multi2) const;
+  inline bool plain_is_equal(const isl::multi_val &multi2, isl::quota &quota) const;
   inline isl::multi_val product(isl::multi_val multi2) const;
   inline isl::multi_val project_domain_on_params() const;
   inline isl::multi_val range_factor_domain() const;
   inline isl::multi_val range_factor_range() const;
-  inline isl::boolean range_is_wrapping() const;
+  inline bool range_is_wrapping(isl::quota &quota) const;
   inline isl::multi_val range_product(isl::multi_val multi2) const;
   inline isl::multi_val range_splice(unsigned int pos, isl::multi_val multi2) const;
   inline isl::multi_val reset_tuple_id(isl::dim type) const;
   inline isl::multi_val reset_user() const;
   inline isl::multi_val scale_down_multi_val(isl::multi_val mv) const;
   inline isl::multi_val scale_down_val(isl::val v) const;
   inline isl::multi_val scale_multi_val(isl::multi_val mv) const;
   inline isl::multi_val scale_val(isl::val v) const;
public:
   inline isl::pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::pw_aff drop_unused_params() const;
   static inline isl::pw_aff empty(isl::space dim);
   inline isl::map eq_map(isl::pw_aff pa2) const;
   inline isl::set eq_set(isl::pw_aff pwaff2) const;
   inline isl::val eval(isl::point pnt) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::pw_aff floor() const;
-  inline isl::stat foreach_piece(const std::function<isl::stat(isl::set, isl::aff)> &fn) const;
+  inline void foreach_piece(const std::function<void(isl::set, isl::aff)> &fn) const;
   inline isl::pw_aff from_range() const;
   inline isl::set ge_set(isl::pw_aff pwaff2) const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline uint32_t get_hash() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline isl::pw_aff gist(isl::set context) const;
   inline isl::pw_aff gist_params(isl::set context) const;
   inline isl::map gt_map(isl::pw_aff pa2) const;
   inline isl::set gt_set(isl::pw_aff pwaff2) const;
-  inline isl::boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
+  inline bool has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
   inline isl::pw_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::pw_aff intersect_domain(isl::set set) const;
   inline isl::pw_aff intersect_params(isl::set set) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_nan() const;
-  inline isl::boolean is_cst() const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::pw_aff &pa2) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool involves_nan(isl::quota &quota) const;
+  inline bool is_cst(isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::pw_aff &pa2, isl::quota &quota) const;
   inline isl::set le_set(isl::pw_aff pwaff2) const;
   inline isl::map lt_map(isl::pw_aff pa2) const;
   inline isl::set lt_set(isl::pw_aff pwaff2) const;
   inline isl::pw_aff max(isl::pw_aff pwaff2) const;
   inline isl::pw_aff min(isl::pw_aff pwaff2) const;
   inline isl::pw_aff mod(isl::val mod) const;
   inline isl::pw_aff move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline isl::pw_aff mul(isl::pw_aff pwaff2) const;
   inline int n_piece() const;
   static inline isl::pw_aff nan_on_domain(isl::local_space ls);
   inline isl::set ne_set(isl::pw_aff pwaff2) const;
   inline isl::pw_aff neg() const;
   inline isl::set non_zero_set() const;
   inline isl::set nonneg_set() const;
   inline isl::set params() const;
   inline int plain_cmp(const isl::pw_aff &pa2) const;
-  inline isl::boolean plain_is_equal(const isl::pw_aff &pwaff2) const;
+  inline bool plain_is_equal(const isl::pw_aff &pwaff2, isl::quota &quota) const;
   inline isl::set pos_set() const;
   inline isl::pw_aff project_domain_on_params() const;
   inline isl::pw_aff pullback(isl::multi_aff ma) const;
   inline isl::pw_aff pullback(isl::pw_multi_aff pma) const;
   inline isl::pw_aff pullback(isl::multi_pw_aff mpa) const;
   inline isl::pw_aff reset_tuple_id(isl::dim type) const;
   inline isl::pw_aff reset_user() const;
   inline isl::pw_aff scale(isl::val v) const;
public:
   inline unsigned int dim(isl::dim type) const;
   inline isl::set domain() const;
   inline isl::pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::pw_multi_aff drop_unused_params() const;
   static inline isl::pw_multi_aff empty(isl::space space);
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::pw_multi_aff fix_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::pw_multi_aff flat_range_product(isl::pw_multi_aff pma2) const;
-  inline isl::stat foreach_piece(const std::function<isl::stat(isl::set, isl::multi_aff)> &fn) const;
+  inline void foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const;
   static inline isl::pw_multi_aff from_domain(isl::set set);
   static inline isl::pw_multi_aff from_map(isl::map map);
   static inline isl::pw_multi_aff from_multi_pw_aff(isl::multi_pw_aff mpa);
   static inline isl::pw_multi_aff from_set(isl::set set);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::pw_aff get_pw_aff(int pos) const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::pw_multi_aff gist(isl::set set) const;
   inline isl::pw_multi_aff gist_params(isl::set set) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
-  inline isl::boolean has_tuple_name(isl::dim type) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
+  inline bool has_tuple_name(isl::dim type, isl::quota &quota) const;
   static inline isl::pw_multi_aff identity(isl::space space);
   inline isl::pw_multi_aff intersect_domain(isl::set set) const;
   inline isl::pw_multi_aff intersect_params(isl::set set) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_nan() const;
-  inline isl::boolean is_equal(const isl::pw_multi_aff &pma2) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool involves_nan(isl::quota &quota) const;
+  inline bool is_equal(const isl::pw_multi_aff &pma2, isl::quota &quota) const;
   static inline isl::pw_multi_aff multi_val_on_domain(isl::set domain, isl::multi_val mv);
   inline int n_piece() const;
   inline isl::pw_multi_aff neg() const;
-  inline isl::boolean plain_is_equal(const isl::pw_multi_aff &pma2) const;
+  inline bool plain_is_equal(const isl::pw_multi_aff &pma2, isl::quota &quota) const;
   inline isl::pw_multi_aff product(isl::pw_multi_aff pma2) const;
   inline isl::pw_multi_aff project_domain_on_params() const;
   static inline isl::pw_multi_aff project_out_map(isl::space space, isl::dim type, unsigned int first, unsigned int n);
   inline isl::pw_multi_aff pullback(isl::multi_aff ma) const;
   inline isl::pw_multi_aff pullback(isl::pw_multi_aff pma2) const;
   static inline isl::pw_multi_aff range_map(isl::space space);
   inline isl::pw_multi_aff range_product(isl::pw_multi_aff pma2) const;
   inline isl::pw_multi_aff reset_tuple_id(isl::dim type) const;
public:
   inline isl::pw_qpolynomial coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::set domain() const;
   inline isl::pw_qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::pw_qpolynomial drop_unused_params() const;
   inline isl::val eval(isl::point pnt) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::pw_qpolynomial fix_val(isl::dim type, unsigned int n, isl::val v) const;
-  inline isl::stat foreach_piece(const std::function<isl::stat(isl::set, isl::qpolynomial)> &fn) const;
+  inline void foreach_piece(const std::function<void(isl::set, isl::qpolynomial)> &fn) const;
   static inline isl::pw_qpolynomial from_pw_aff(isl::pw_aff pwaff);
   static inline isl::pw_qpolynomial from_qpolynomial(isl::qpolynomial qp);
   inline isl::pw_qpolynomial from_range() const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::pw_qpolynomial gist(isl::set context) const;
   inline isl::pw_qpolynomial gist_params(isl::set context) const;
-  inline isl::boolean has_equal_space(const isl::pw_qpolynomial &pwqp2) const;
+  inline bool has_equal_space(const isl::pw_qpolynomial &pwqp2, isl::quota &quota) const;
   inline isl::pw_qpolynomial insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::pw_qpolynomial intersect_domain(isl::set set) const;
   inline isl::pw_qpolynomial intersect_params(isl::set set) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_nan() const;
-  inline isl::boolean is_zero() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool involves_nan(isl::quota &quota) const;
+  inline bool is_zero(isl::quota &quota) const;
   inline isl::val max() const;
   inline isl::val min() const;
   inline isl::pw_qpolynomial move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline isl::pw_qpolynomial mul(isl::pw_qpolynomial pwqp2) const;
   inline int n_piece() const;
   inline isl::pw_qpolynomial neg() const;
-  inline isl::boolean plain_is_equal(const isl::pw_qpolynomial &pwqp2) const;
+  inline bool plain_is_equal(const isl::pw_qpolynomial &pwqp2, isl::quota &quota) const;
   inline isl::pw_qpolynomial pow(unsigned int exponent) const;
   inline isl::pw_qpolynomial project_domain_on_params() const;
   inline isl::pw_qpolynomial reset_domain_space(isl::space dim) const;
   inline isl::pw_qpolynomial reset_user() const;
   inline isl::pw_qpolynomial scale_down_val(isl::val v) const;
   inline isl::pw_qpolynomial scale_val(isl::val v) const;
   inline isl::pw_qpolynomial split_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::pw_qpolynomial split_periods(int max_periods) const;
public:
   inline bool is_null() const;
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline void dump() const;
 
   inline isl::qpolynomial add(isl::qpolynomial qp2) const;
   inline isl::qpolynomial add_dims(isl::dim type, unsigned int n) const;
   inline isl::qpolynomial align_params(isl::space model) const;
-  inline isl::stat as_polynomial_on_domain(const isl::basic_set &bset, const std::function<isl::stat(isl::basic_set, isl::qpolynomial)> &fn) const;
+  inline void as_polynomial_on_domain(const isl::basic_set &bset, const std::function<void(isl::basic_set, isl::qpolynomial)> &fn) const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::val eval(isl::point pnt) const;
-  inline isl::stat foreach_term(const std::function<isl::stat(isl::term)> &fn) const;
+  inline void foreach_term(const std::function<void(isl::term)> &fn) const;
   static inline isl::qpolynomial from_aff(isl::aff aff);
   static inline isl::qpolynomial from_constraint(isl::constraint c, isl::dim type, unsigned int pos);
   static inline isl::qpolynomial from_term(isl::term term);
   inline isl::val get_constant_val() const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::qpolynomial gist(isl::set context) const;
   inline isl::qpolynomial gist_params(isl::set context) const;
   inline isl::qpolynomial homogenize() const;
   static inline isl::qpolynomial infty_on_domain(isl::space dim);
   inline isl::qpolynomial insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_infty() const;
-  inline isl::boolean is_nan() const;
-  inline isl::boolean is_neginfty() const;
-  inline isl::boolean is_zero() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_infty(isl::quota &quota) const;
+  inline bool is_nan(isl::quota &quota) const;
+  inline bool is_neginfty(isl::quota &quota) const;
+  inline bool is_zero(isl::quota &quota) const;
   inline isl::qpolynomial move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline isl::qpolynomial mul(isl::qpolynomial qp2) const;
   static inline isl::qpolynomial nan_on_domain(isl::space dim);
   inline isl::qpolynomial neg() const;
   static inline isl::qpolynomial neginfty_on_domain(isl::space dim);
   static inline isl::qpolynomial one_on_domain(isl::space dim);
-  inline isl::boolean plain_is_equal(const isl::qpolynomial &qp2) const;
+  inline bool plain_is_equal(const isl::qpolynomial &qp2, isl::quota &quota) const;
   inline isl::qpolynomial pow(unsigned int power) const;
   inline isl::qpolynomial project_domain_on_params() const;
   inline isl::qpolynomial scale_down_val(isl::val v) const;
   inline isl::qpolynomial scale_val(isl::val v) const;
   inline int sgn() const;
   inline isl::qpolynomial sub(isl::qpolynomial qp2) const;
   static inline isl::qpolynomial val_on_domain(isl::space space, isl::val val);
   static inline isl::qpolynomial var_on_domain(isl::space dim, isl::dim type, unsigned int pos);
public:
   inline isl::union_set get_domain() const;
   inline isl::union_map get_map() const;
   inline isl::schedule_node get_root() const;
   inline isl::schedule gist_domain_params(isl::set context) const;
   inline isl::schedule insert_context(isl::set context) const;
   inline isl::schedule insert_guard(isl::set guard) const;
   inline isl::schedule insert_partial_schedule(isl::multi_union_pw_aff partial) const;
   inline isl::schedule intersect_domain(isl::union_set domain) const;
-  inline isl::boolean plain_is_equal(const isl::schedule &schedule2) const;
+  inline bool plain_is_equal(const isl::schedule &schedule2, isl::quota &quota) const;
   inline isl::schedule pullback(isl::union_pw_multi_aff upma) const;
   inline isl::schedule reset_user() const;
   inline isl::schedule sequence(isl::schedule schedule2) const;
   inline isl::schedule set(isl::schedule schedule2) const;
 };
 
 // declarations for isl::schedule_constraints
 inline isl::schedule_constraints manage(__isl_take isl_schedule_constraints *ptr);
public:
   inline bool is_null() const;
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline isl::schedule_node align_params(isl::space space) const;
   inline isl::schedule_node ancestor(int generation) const;
-  inline isl::boolean band_member_get_coincident(int pos) const;
+  inline bool band_member_get_coincident(int pos, isl::quota &quota) const;
   inline isl::schedule_node band_member_set_coincident(int pos, int coincident) const;
   inline isl::schedule_node band_set_ast_build_options(isl::union_set options) const;
   inline isl::schedule_node child(int pos) const;
   inline isl::set context_get_context() const;
   inline isl::schedule_node cut() const;
   inline isl::union_set domain_get_domain() const;
   inline isl::union_pw_multi_aff expansion_get_contraction() const;
   inline isl::union_map expansion_get_expansion() const;
   inline isl::union_map extension_get_extension() const;
   inline isl::union_set filter_get_filter() const;
   inline isl::schedule_node first_child() const;
-  inline isl::stat foreach_ancestor_top_down(const std::function<isl::stat(isl::schedule_node)> &fn) const;
+  inline void foreach_ancestor_top_down(const std::function<void(isl::schedule_node)> &fn) const;
   static inline isl::schedule_node from_domain(isl::union_set domain);
   static inline isl::schedule_node from_extension(isl::union_map extension);
   inline int get_ancestor_child_position(const isl::schedule_node &ancestor) const;
   inline isl::schedule_node get_child(int pos) const;
   inline int get_child_position() const;
   inline isl::union_set get_domain() const;
   inline isl::multi_union_pw_aff get_prefix_schedule_multi_union_pw_aff() const;
   inline isl::union_map get_prefix_schedule_relation() const;
   inline isl::union_map get_prefix_schedule_union_map() const;
   inline isl::union_pw_multi_aff get_prefix_schedule_union_pw_multi_aff() const;
   inline isl::schedule get_schedule() const;
   inline int get_schedule_depth() const;
   inline isl::schedule_node get_shared_ancestor(const isl::schedule_node &node2) const;
   inline isl::union_pw_multi_aff get_subtree_contraction() const;
   inline isl::union_map get_subtree_expansion() const;
   inline isl::union_map get_subtree_schedule_union_map() const;
   inline int get_tree_depth() const;
   inline isl::union_set get_universe_domain() const;
   inline isl::schedule_node graft_after(isl::schedule_node graft) const;
   inline isl::schedule_node graft_before(isl::schedule_node graft) const;
   inline isl::schedule_node group(isl::id group_id) const;
   inline isl::set guard_get_guard() const;
-  inline isl::boolean has_children() const;
-  inline isl::boolean has_next_sibling() const;
-  inline isl::boolean has_parent() const;
-  inline isl::boolean has_previous_sibling() const;
+  inline bool has_children(isl::quota &quota) const;
+  inline bool has_next_sibling(isl::quota &quota) const;
+  inline bool has_parent(isl::quota &quota) const;
+  inline bool has_previous_sibling(isl::quota &quota) const;
   inline isl::schedule_node insert_context(isl::set context) const;
   inline isl::schedule_node insert_filter(isl::union_set filter) const;
   inline isl::schedule_node insert_guard(isl::set context) const;
   inline isl::schedule_node insert_mark(isl::id mark) const;
   inline isl::schedule_node insert_partial_schedule(isl::multi_union_pw_aff schedule) const;
   inline isl::schedule_node insert_sequence(isl::union_set_list filters) const;
   inline isl::schedule_node insert_set(isl::union_set_list filters) const;
-  inline isl::boolean is_equal(const isl::schedule_node &node2) const;
-  inline isl::boolean is_subtree_anchored() const;
+  inline bool is_equal(const isl::schedule_node &node2, isl::quota &quota) const;
+  inline bool is_subtree_anchored(isl::quota &quota) const;
   inline isl::id mark_get_id() const;
   inline int n_children() const;
   inline isl::schedule_node next_sibling() const;
   inline isl::schedule_node order_after(isl::union_set filter) const;
   inline isl::schedule_node order_before(isl::union_set filter) const;
   inline isl::schedule_node parent() const;
   inline isl::schedule_node previous_sibling() const;
   inline isl::schedule_node reset_user() const;
public:
   static inline isl::set box_from_points(isl::point pnt1, isl::point pnt2);
   inline isl::set coalesce() const;
   inline isl::basic_set coefficients() const;
   inline isl::set complement() const;
   inline isl::basic_set convex_hull() const;
   inline isl::val count_val() const;
   inline isl::set detect_equalities() const;
   inline unsigned int dim(isl::dim type) const;
-  inline isl::boolean dim_has_any_lower_bound(isl::dim type, unsigned int pos) const;
-  inline isl::boolean dim_has_any_upper_bound(isl::dim type, unsigned int pos) const;
-  inline isl::boolean dim_has_lower_bound(isl::dim type, unsigned int pos) const;
-  inline isl::boolean dim_has_upper_bound(isl::dim type, unsigned int pos) const;
-  inline isl::boolean dim_is_bounded(isl::dim type, unsigned int pos) const;
+  inline bool dim_has_any_lower_bound(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool dim_has_any_upper_bound(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool dim_has_lower_bound(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool dim_has_upper_bound(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool dim_is_bounded(isl::dim type, unsigned int pos, isl::quota &quota) const;
   inline isl::pw_aff dim_max(int pos) const;
   inline isl::pw_aff dim_min(int pos) const;
   inline isl::set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set drop_unused_params() const;
   inline isl::set eliminate(isl::dim type, unsigned int first, unsigned int n) const;
   static inline isl::set empty(isl::space space);
   inline isl::set equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
   inline int find_dim_by_id(isl::dim type, const isl::id &id) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::set fix_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::set fix_val(isl::dim type, unsigned int pos, isl::val v) const;
   inline isl::set flat_product(isl::set set2) const;
   inline isl::set flatten() const;
   inline isl::map flatten_map() const;
   inline int follows_at(const isl::set &set2, int pos) const;
-  inline isl::stat foreach_basic_set(const std::function<isl::stat(isl::basic_set)> &fn) const;
-  inline isl::stat foreach_point(const std::function<isl::stat(isl::point)> &fn) const;
+  inline void foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const;
+  inline void foreach_point(const std::function<void(isl::point)> &fn) const;
   static inline isl::set from_multi_pw_aff(isl::multi_pw_aff mpa);
   inline isl::set from_params() const;
   static inline isl::set from_pw_aff(isl::pw_aff pwaff);
   static inline isl::set from_pw_multi_aff(isl::pw_multi_aff pma);
   inline isl::basic_set_list get_basic_set_list() const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::space get_space() const;
   inline isl::val get_stride(int pos) const;
   inline isl::id get_tuple_id() const;
   inline std::string get_tuple_name() const;
   inline isl::set gist(isl::set context) const;
   inline isl::set gist_basic_set(isl::basic_set context) const;
   inline isl::set gist_params(isl::set context) const;
-  inline isl::boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_dim_name(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_equal_space(const isl::set &set2) const;
-  inline isl::boolean has_tuple_id() const;
-  inline isl::boolean has_tuple_name() const;
+  inline bool has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_equal_space(const isl::set &set2, isl::quota &quota) const;
+  inline bool has_tuple_id(isl::quota &quota) const;
+  inline bool has_tuple_name(isl::quota &quota) const;
   inline isl::map identity() const;
   inline isl::pw_aff indicator_function() const;
   inline isl::set insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
   inline isl::set intersect(isl::set set2) const;
   inline isl::set intersect_params(isl::set params) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_bounded() const;
-  inline isl::boolean is_box() const;
-  inline isl::boolean is_disjoint(const isl::set &set2) const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::set &set2) const;
-  inline isl::boolean is_params() const;
-  inline isl::boolean is_singleton() const;
-  inline isl::boolean is_strict_subset(const isl::set &set2) const;
-  inline isl::boolean is_subset(const isl::set &set2) const;
-  inline isl::boolean is_wrapping() const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_bounded(isl::quota &quota) const;
+  inline bool is_box(isl::quota &quota) const;
+  inline bool is_disjoint(const isl::set &set2, isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::set &set2, isl::quota &quota) const;
+  inline bool is_params(isl::quota &quota) const;
+  inline bool is_singleton(isl::quota &quota) const;
+  inline bool is_strict_subset(const isl::set &set2, isl::quota &quota) const;
+  inline bool is_subset(const isl::set &set2, isl::quota &quota) const;
+  inline bool is_wrapping(isl::quota &quota) const;
   inline isl::map lex_ge_set(isl::set set2) const;
   inline isl::map lex_gt_set(isl::set set2) const;
   inline isl::map lex_le_set(isl::set set2) const;
   inline isl::map lex_lt_set(isl::set set2) const;
   inline isl::set lexmax() const;
   inline isl::pw_multi_aff lexmax_pw_multi_aff() const;
   inline isl::set lexmin() const;
   inline isl::pw_multi_aff lexmin_pw_multi_aff() const;
   inline isl::set lower_bound_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::set lower_bound_val(isl::dim type, unsigned int pos, isl::val value) const;
   inline isl::val max_val(const isl::aff &obj) const;
   inline isl::val min_val(const isl::aff &obj) const;
   inline isl::set move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline int n_basic_set() const;
   inline unsigned int n_dim() const;
   static inline isl::set nat_universe(isl::space dim);
   inline isl::set neg() const;
   inline isl::set params() const;
   inline int plain_cmp(const isl::set &set2) const;
   inline isl::val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
-  inline isl::boolean plain_is_disjoint(const isl::set &set2) const;
-  inline isl::boolean plain_is_empty() const;
-  inline isl::boolean plain_is_equal(const isl::set &set2) const;
-  inline isl::boolean plain_is_universe() const;
+  inline bool plain_is_disjoint(const isl::set &set2, isl::quota &quota) const;
+  inline bool plain_is_empty(isl::quota &quota) const;
+  inline bool plain_is_equal(const isl::set &set2, isl::quota &quota) const;
+  inline bool plain_is_universe(isl::quota &quota) const;
   inline isl::basic_set plain_unshifted_simple_hull() const;
   inline isl::basic_set polyhedral_hull() const;
   inline isl::set preimage_multi_aff(isl::multi_aff ma) const;
   inline isl::set preimage_multi_pw_aff(isl::multi_pw_aff mpa) const;
   inline isl::set preimage_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::set product(isl::set set2) const;
   inline isl::map project_onto_map(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set project_out(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline isl::space add_dims(isl::dim type, unsigned int n) const;
   inline isl::space add_param_id(isl::id id) const;
   inline isl::space align_params(isl::space dim2) const;
-  inline isl::boolean can_curry() const;
-  inline isl::boolean can_range_curry() const;
-  inline isl::boolean can_uncurry() const;
-  inline isl::boolean can_zip() const;
+  inline bool can_curry(isl::quota &quota) const;
+  inline bool can_range_curry(isl::quota &quota) const;
+  inline bool can_uncurry(isl::quota &quota) const;
+  inline bool can_zip(isl::quota &quota) const;
   inline isl::space curry() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::space domain() const;
   inline isl::space domain_factor_domain() const;
   inline isl::space domain_factor_range() const;
-  inline isl::boolean domain_is_wrapping() const;
+  inline bool domain_is_wrapping(isl::quota &quota) const;
   inline isl::space domain_map() const;
   inline isl::space domain_product(isl::space right) const;
   inline isl::space drop_dims(isl::dim type, unsigned int first, unsigned int num) const;
   inline isl::space factor_domain() const;
   inline isl::space factor_range() const;
   inline int find_dim_by_id(isl::dim type, const isl::id &id) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::space flatten_domain() const;
   inline isl::space flatten_range() const;
   inline isl::space from_domain() const;
   inline isl::space from_range() const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
-  inline isl::boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_dim_name(isl::dim type, unsigned int pos) const;
-  inline isl::boolean has_equal_params(const isl::space &space2) const;
-  inline isl::boolean has_equal_tuples(const isl::space &space2) const;
-  inline isl::boolean has_tuple_id(isl::dim type) const;
-  inline isl::boolean has_tuple_name(isl::dim type) const;
+  inline bool has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const;
+  inline bool has_equal_params(const isl::space &space2, isl::quota &quota) const;
+  inline bool has_equal_tuples(const isl::space &space2, isl::quota &quota) const;
+  inline bool has_tuple_id(isl::dim type, isl::quota &quota) const;
+  inline bool has_tuple_name(isl::dim type, isl::quota &quota) const;
   inline isl::space insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
-  inline isl::boolean is_domain(const isl::space &space2) const;
-  inline isl::boolean is_equal(const isl::space &space2) const;
-  inline isl::boolean is_map() const;
-  inline isl::boolean is_params() const;
-  inline isl::boolean is_product() const;
-  inline isl::boolean is_range(const isl::space &space2) const;
-  inline isl::boolean is_set() const;
-  inline isl::boolean is_wrapping() const;
+  inline bool is_domain(const isl::space &space2, isl::quota &quota) const;
+  inline bool is_equal(const isl::space &space2, isl::quota &quota) const;
+  inline bool is_map(isl::quota &quota) const;
+  inline bool is_params(isl::quota &quota) const;
+  inline bool is_product(isl::quota &quota) const;
+  inline bool is_range(const isl::space &space2, isl::quota &quota) const;
+  inline bool is_set(isl::quota &quota) const;
+  inline bool is_wrapping(isl::quota &quota) const;
   inline isl::space join(isl::space right) const;
   inline isl::space map_from_domain_and_range(isl::space range) const;
   inline isl::space map_from_set() const;
   inline isl::space move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
   inline isl::space params() const;
   static inline isl::space params_alloc(isl::ctx ctx, unsigned int nparam);
   inline isl::space product(isl::space right) const;
   inline isl::space range() const;
   inline isl::space range_curry() const;
   inline isl::space range_factor_domain() const;
   inline isl::space range_factor_range() const;
-  inline isl::boolean range_is_wrapping() const;
+  inline bool range_is_wrapping(isl::quota &quota) const;
   inline isl::space range_map() const;
   inline isl::space range_product(isl::space right) const;
   inline isl::space reset_tuple_id(isl::dim type) const;
   inline isl::space reset_user() const;
   inline isl::space reverse() const;
   inline isl::space set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
   inline isl::space set_from_params() const;
   inline isl::space set_tuple_id(isl::dim type, isl::id id) const;
   inline isl::space set_tuple_name(isl::dim type, const std::string &s) const;
-  inline isl::boolean tuple_is_equal(isl::dim type1, const isl::space &space2, isl::dim type2) const;
+  inline bool tuple_is_equal(isl::dim type1, const isl::space &space2, isl::dim type2, isl::quota &quota) const;
   inline isl::space uncurry() const;
   inline isl::space unwrap() const;
   inline isl::space wrap() const;
   inline isl::space zip() const;
 };
 
 // declarations for isl::term
 inline isl::term manage(__isl_take isl_term *ptr);
public:
   inline void dump() const;
 
   inline isl::union_map add_map(isl::map map) const;
   inline isl::union_map affine_hull() const;
   inline isl::union_map align_params(isl::space model) const;
   inline isl::union_map apply_domain(isl::union_map umap2) const;
   inline isl::union_map apply_range(isl::union_map umap2) const;
   inline isl::union_map coalesce() const;
-  inline isl::boolean contains(const isl::space &space) const;
+  inline bool contains(const isl::space &space, isl::quota &quota) const;
   inline isl::union_map curry() const;
   inline isl::union_set deltas() const;
   inline isl::union_map deltas_map() const;
   inline isl::union_map detect_equalities() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::union_set domain() const;
   inline isl::union_map domain_factor_domain() const;
   inline isl::union_map domain_factor_range() const;
   inline isl::union_map domain_map() const;
   inline isl::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
   inline isl::union_map domain_product(isl::union_map umap2) const;
   static inline isl::union_map empty(isl::space space);
   inline isl::union_map eq_at(isl::multi_union_pw_aff mupa) const;
   inline isl::map extract_map(isl::space dim) const;
   inline isl::union_map factor_domain() const;
   inline isl::union_map factor_range() const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::union_map fixed_power(isl::val exp) const;
   inline isl::union_map flat_domain_product(isl::union_map umap2) const;
   inline isl::union_map flat_range_product(isl::union_map umap2) const;
-  inline isl::stat foreach_map(const std::function<isl::stat(isl::map)> &fn) const;
+  inline void foreach_map(const std::function<void(isl::map)> &fn) const;
   static inline isl::union_map from(isl::union_pw_multi_aff upma);
   static inline isl::union_map from(isl::multi_union_pw_aff mupa);
   static inline isl::union_map from_domain(isl::union_set uset);
   static inline isl::union_map from_domain_and_range(isl::union_set domain, isl::union_set range);
   static inline isl::union_map from_range(isl::union_set uset);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline uint32_t get_hash() const;
   inline isl::space get_space() const;
   inline isl::union_map gist(isl::union_map context) const;
   inline isl::union_map gist_domain(isl::union_set uset) const;
   inline isl::union_map gist_params(isl::set set) const;
   inline isl::union_map gist_range(isl::union_set uset) const;
   inline isl::union_map intersect(isl::union_map umap2) const;
   inline isl::union_map intersect_domain(isl::union_set uset) const;
   inline isl::union_map intersect_params(isl::set set) const;
   inline isl::union_map intersect_range(isl::union_set uset) const;
   inline isl::union_map intersect_range_factor_range(isl::union_map factor) const;
-  inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::boolean is_bijective() const;
-  inline isl::boolean is_disjoint(const isl::union_map &umap2) const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::union_map &umap2) const;
-  inline isl::boolean is_identity() const;
-  inline isl::boolean is_injective() const;
-  inline isl::boolean is_single_valued() const;
-  inline isl::boolean is_strict_subset(const isl::union_map &umap2) const;
-  inline isl::boolean is_subset(const isl::union_map &umap2) const;
+  inline bool involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const;
+  inline bool is_bijective(isl::quota &quota) const;
+  inline bool is_disjoint(const isl::union_map &umap2, isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::union_map &umap2, isl::quota &quota) const;
+  inline bool is_identity(isl::quota &quota) const;
+  inline bool is_injective(isl::quota &quota) const;
+  inline bool is_single_valued(isl::quota &quota) const;
+  inline bool is_strict_subset(const isl::union_map &umap2, isl::quota &quota) const;
+  inline bool is_subset(const isl::union_map &umap2, isl::quota &quota) const;
   inline isl::union_map lex_ge_union_map(isl::union_map umap2) const;
   inline isl::union_map lex_gt_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) const;
   inline isl::union_map lex_gt_union_map(isl::union_map umap2) const;
   inline isl::union_map lex_le_union_map(isl::union_map umap2) const;
   inline isl::union_map lex_lt_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) const;
   inline isl::union_map lex_lt_union_map(isl::union_map umap2) const;
   inline isl::union_map lexmax() const;
   inline isl::union_map lexmin() const;
   inline int n_map() const;
   inline isl::set params() const;
-  inline isl::boolean plain_is_empty() const;
-  inline isl::boolean plain_is_injective() const;
+  inline bool plain_is_empty(isl::quota &quota) const;
+  inline bool plain_is_injective(isl::quota &quota) const;
   inline isl::union_map polyhedral_hull() const;
   inline isl::union_map preimage_domain_multi_aff(isl::multi_aff ma) const;
   inline isl::union_map preimage_domain_multi_pw_aff(isl::multi_pw_aff mpa) const;
   inline isl::union_map preimage_domain_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::union_map preimage_domain_union_pw_multi_aff(isl::union_pw_multi_aff upma) const;
   inline isl::union_map preimage_range_multi_aff(isl::multi_aff ma) const;
   inline isl::union_map preimage_range_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::union_map preimage_range_union_pw_multi_aff(isl::union_pw_multi_aff upma) const;
public:
   inline isl::union_pw_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::union_set domain() const;
   inline isl::union_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   static inline isl::union_pw_aff empty(isl::space space);
   inline isl::pw_aff extract_pw_aff(isl::space space) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::union_pw_aff floor() const;
-  inline isl::stat foreach_pw_aff(const std::function<isl::stat(isl::pw_aff)> &fn) const;
+  inline void foreach_pw_aff(const std::function<void(isl::pw_aff)> &fn) const;
   inline isl::space get_space() const;
   inline isl::union_pw_aff gist(isl::union_set context) const;
   inline isl::union_pw_aff gist_params(isl::set context) const;
   inline isl::union_pw_aff intersect_domain(isl::union_set uset) const;
   inline isl::union_pw_aff intersect_params(isl::set set) const;
-  inline isl::boolean involves_nan() const;
+  inline bool involves_nan(isl::quota &quota) const;
   inline isl::union_pw_aff mod_val(isl::val f) const;
   inline int n_pw_aff() const;
   inline isl::union_pw_aff neg() const;
   static inline isl::union_pw_aff param_on_domain_id(isl::union_set domain, isl::id id);
-  inline isl::boolean plain_is_equal(const isl::union_pw_aff &upa2) const;
+  inline bool plain_is_equal(const isl::union_pw_aff &upa2, isl::quota &quota) const;
   inline isl::union_pw_aff pullback(isl::union_pw_multi_aff upma) const;
   static inline isl::union_pw_aff pw_aff_on_domain(isl::union_set domain, isl::pw_aff pa);
   inline isl::union_pw_aff reset_user() const;
   inline isl::union_pw_aff scale_down_val(isl::val v) const;
   inline isl::union_pw_aff scale_val(isl::val v) const;
   inline isl::union_pw_aff sub(isl::union_pw_aff upa2) const;
   inline isl::union_pw_aff subtract_domain(isl::union_set uset) const;
   inline isl::union_pw_aff union_add(isl::union_pw_aff upa2) const;
public:
   inline isl::union_pw_multi_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::union_set domain() const;
   inline isl::union_pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   static inline isl::union_pw_multi_aff empty(isl::space space);
   inline isl::pw_multi_aff extract_pw_multi_aff(isl::space space) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::union_pw_multi_aff flat_range_product(isl::union_pw_multi_aff upma2) const;
-  inline isl::stat foreach_pw_multi_aff(const std::function<isl::stat(isl::pw_multi_aff)> &fn) const;
+  inline void foreach_pw_multi_aff(const std::function<void(isl::pw_multi_aff)> &fn) const;
   static inline isl::union_pw_multi_aff from_aff(isl::aff aff);
   static inline isl::union_pw_multi_aff from_multi_union_pw_aff(isl::multi_union_pw_aff mupa);
   static inline isl::union_pw_multi_aff from_union_set(isl::union_set uset);
   inline isl::space get_space() const;
   inline isl::union_pw_aff get_union_pw_aff(int pos) const;
   inline isl::union_pw_multi_aff gist(isl::union_set context) const;
   inline isl::union_pw_multi_aff gist_params(isl::set context) const;
   inline isl::union_pw_multi_aff intersect_domain(isl::union_set uset) const;
   inline isl::union_pw_multi_aff intersect_params(isl::set set) const;
-  inline isl::boolean involves_nan() const;
+  inline bool involves_nan(isl::quota &quota) const;
   static inline isl::union_pw_multi_aff multi_val_on_domain(isl::union_set domain, isl::multi_val mv);
   inline int n_pw_multi_aff() const;
   inline isl::union_pw_multi_aff neg() const;
-  inline isl::boolean plain_is_equal(const isl::union_pw_multi_aff &upma2) const;
+  inline bool plain_is_equal(const isl::union_pw_multi_aff &upma2, isl::quota &quota) const;
   inline isl::union_pw_multi_aff pullback(isl::union_pw_multi_aff upma2) const;
   inline isl::union_pw_multi_aff reset_user() const;
   inline isl::union_pw_multi_aff scale_down_val(isl::val val) const;
   inline isl::union_pw_multi_aff scale_multi_val(isl::multi_val mv) const;
   inline isl::union_pw_multi_aff scale_val(isl::val val) const;
   inline isl::union_pw_multi_aff sub(isl::union_pw_multi_aff upma2) const;
   inline isl::union_pw_multi_aff subtract_domain(isl::union_set uset) const;
   inline isl::union_pw_multi_aff union_add(isl::union_pw_multi_aff upma2) const;
public:
   inline isl::union_pw_qpolynomial align_params(isl::space model) const;
   inline isl::union_pw_qpolynomial coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::union_set domain() const;
   inline isl::union_pw_qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::val eval(isl::point pnt) const;
   inline isl::pw_qpolynomial extract_pw_qpolynomial(isl::space dim) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
-  inline isl::stat foreach_pw_qpolynomial(const std::function<isl::stat(isl::pw_qpolynomial)> &fn) const;
+  inline void foreach_pw_qpolynomial(const std::function<void(isl::pw_qpolynomial)> &fn) const;
   static inline isl::union_pw_qpolynomial from_pw_qpolynomial(isl::pw_qpolynomial pwqp);
   inline isl::space get_space() const;
   inline isl::union_pw_qpolynomial gist(isl::union_set context) const;
   inline isl::union_pw_qpolynomial gist_params(isl::set context) const;
   inline isl::union_pw_qpolynomial intersect_domain(isl::union_set uset) const;
   inline isl::union_pw_qpolynomial intersect_params(isl::set set) const;
-  inline isl::boolean involves_nan() const;
+  inline bool involves_nan(isl::quota &quota) const;
   inline isl::union_pw_qpolynomial mul(isl::union_pw_qpolynomial upwqp2) const;
   inline int n_pw_qpolynomial() const;
   inline isl::union_pw_qpolynomial neg() const;
-  inline isl::boolean plain_is_equal(const isl::union_pw_qpolynomial &upwqp2) const;
+  inline bool plain_is_equal(const isl::union_pw_qpolynomial &upwqp2, isl::quota &quota) const;
   inline isl::union_pw_qpolynomial reset_user() const;
   inline isl::union_pw_qpolynomial scale_down_val(isl::val v) const;
   inline isl::union_pw_qpolynomial scale_val(isl::val v) const;
   inline isl::union_pw_qpolynomial sub(isl::union_pw_qpolynomial upwqp2) const;
   inline isl::union_pw_qpolynomial subtract_domain(isl::union_set uset) const;
   inline isl::union_pw_qpolynomial to_polynomial(int sign) const;
   static inline isl::union_pw_qpolynomial zero(isl::space dim);
 };
public:
 
   inline isl::union_set add_set(isl::set set) const;
   inline isl::union_set affine_hull() const;
   inline isl::union_set align_params(isl::space model) const;
   inline isl::union_set apply(isl::union_map umap) const;
   inline isl::union_set coalesce() const;
   inline isl::union_set coefficients() const;
   inline isl::schedule compute_schedule(isl::union_map validity, isl::union_map proximity) const;
-  inline isl::boolean contains(const isl::space &space) const;
+  inline bool contains(const isl::space &space, isl::quota &quota) const;
   inline isl::union_set detect_equalities() const;
   inline unsigned int dim(isl::dim type) const;
   static inline isl::union_set empty(isl::space space);
   inline isl::set extract_set(isl::space dim) const;
-  inline isl::stat foreach_point(const std::function<isl::stat(isl::point)> &fn) const;
-  inline isl::stat foreach_set(const std::function<isl::stat(isl::set)> &fn) const;
+  inline void foreach_point(const std::function<void(isl::point)> &fn) const;
+  inline void foreach_set(const std::function<void(isl::set)> &fn) const;
   inline isl::basic_set_list get_basic_set_list() const;
   inline uint32_t get_hash() const;
   inline isl::space get_space() const;
   inline isl::union_set gist(isl::union_set context) const;
   inline isl::union_set gist_params(isl::set set) const;
   inline isl::union_map identity() const;
   inline isl::union_pw_multi_aff identity_union_pw_multi_aff() const;
   inline isl::union_set intersect(isl::union_set uset2) const;
   inline isl::union_set intersect_params(isl::set set) const;
-  inline isl::boolean is_disjoint(const isl::union_set &uset2) const;
-  inline isl::boolean is_empty() const;
-  inline isl::boolean is_equal(const isl::union_set &uset2) const;
-  inline isl::boolean is_params() const;
-  inline isl::boolean is_strict_subset(const isl::union_set &uset2) const;
-  inline isl::boolean is_subset(const isl::union_set &uset2) const;
+  inline bool is_disjoint(const isl::union_set &uset2, isl::quota &quota) const;
+  inline bool is_empty(isl::quota &quota) const;
+  inline bool is_equal(const isl::union_set &uset2, isl::quota &quota) const;
+  inline bool is_params(isl::quota &quota) const;
+  inline bool is_strict_subset(const isl::union_set &uset2, isl::quota &quota) const;
+  inline bool is_subset(const isl::union_set &uset2, isl::quota &quota) const;
   inline isl::union_map lex_ge_union_set(isl::union_set uset2) const;
   inline isl::union_map lex_gt_union_set(isl::union_set uset2) const;
   inline isl::union_map lex_le_union_set(isl::union_set uset2) const;
   inline isl::union_map lex_lt_union_set(isl::union_set uset2) const;
   inline isl::union_set lexmax() const;
   inline isl::union_set lexmin() const;
   inline isl::multi_val min_multi_union_pw_aff(const isl::multi_union_pw_aff &obj) const;
   inline int n_set() const;
public:
   inline bool is_null() const;
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline isl::val two_exp() const;
   inline isl::val abs() const;
-  inline isl::boolean abs_eq(const isl::val &v2) const;
+  inline bool abs_eq(const isl::val &v2, isl::quota &quota) const;
   inline isl::val add(isl::val v2) const;
   inline isl::val add_ui(unsigned long v2) const;
   inline isl::val ceil() const;
   inline int cmp_si(long i) const;
   inline isl::val div(isl::val v2) const;
   inline isl::val div_ui(unsigned long v2) const;
-  inline isl::boolean eq(const isl::val &v2) const;
+  inline bool eq(const isl::val &v2, isl::quota &quota) const;
   inline isl::val floor() const;
   inline isl::val gcd(isl::val v2) const;
-  inline isl::boolean ge(const isl::val &v2) const;
+  inline bool ge(const isl::val &v2, isl::quota &quota) const;
   inline uint32_t get_hash() const;
   inline long get_num_si() const;
-  inline isl::boolean gt(const isl::val &v2) const;
-  inline isl::boolean gt_si(long i) const;
+  inline bool gt(const isl::val &v2, isl::quota &quota) const;
+  inline bool gt_si(long i, isl::quota &quota) const;
   static inline isl::val infty(isl::ctx ctx);
   static inline isl::val int_from_ui(isl::ctx ctx, unsigned long u);
   inline isl::val inv() const;
-  inline isl::boolean is_divisible_by(const isl::val &v2) const;
-  inline isl::boolean is_infty() const;
-  inline isl::boolean is_int() const;
-  inline isl::boolean is_nan() const;
-  inline isl::boolean is_neg() const;
-  inline isl::boolean is_neginfty() const;
-  inline isl::boolean is_negone() const;
-  inline isl::boolean is_nonneg() const;
-  inline isl::boolean is_nonpos() const;
-  inline isl::boolean is_one() const;
-  inline isl::boolean is_pos() const;
-  inline isl::boolean is_rat() const;
-  inline isl::boolean is_zero() const;
-  inline isl::boolean le(const isl::val &v2) const;
-  inline isl::boolean lt(const isl::val &v2) const;
+  inline bool is_divisible_by(const isl::val &v2, isl::quota &quota) const;
+  inline bool is_infty(isl::quota &quota) const;
+  inline bool is_int(isl::quota &quota) const;
+  inline bool is_nan(isl::quota &quota) const;
+  inline bool is_neg(isl::quota &quota) const;
+  inline bool is_neginfty(isl::quota &quota) const;
+  inline bool is_negone(isl::quota &quota) const;
+  inline bool is_nonneg(isl::quota &quota) const;
+  inline bool is_nonpos(isl::quota &quota) const;
+  inline bool is_one(isl::quota &quota) const;
+  inline bool is_pos(isl::quota &quota) const;
+  inline bool is_rat(isl::quota &quota) const;
+  inline bool is_zero(isl::quota &quota) const;
+  inline bool le(const isl::val &v2, isl::quota &quota) const;
+  inline bool lt(const isl::val &v2, isl::quota &quota) const;
   inline isl::val max(isl::val v2) const;
   inline isl::val min(isl::val v2) const;
   inline isl::val mod(isl::val v2) const;
   inline isl::val mul(isl::val v2) const;
   inline isl::val mul_ui(unsigned long v2) const;
   inline size_t n_abs_num_chunks(size_t size) const;
   static inline isl::val nan(isl::ctx ctx);
-  inline isl::boolean ne(const isl::val &v2) const;
+  inline bool ne(const isl::val &v2, isl::quota &quota) const;
   inline isl::val neg() const;
   static inline isl::val neginfty(isl::ctx ctx);
   static inline isl::val negone(isl::ctx ctx);
   static inline isl::val one(isl::ctx ctx);
   inline isl::val set_si(long i) const;
   inline int sgn() const;
   inline isl::val sub(isl::val v2) const;
   inline isl::val sub_ui(unsigned long v2) const;
public:
   inline isl::vec clr() const;
   inline int cmp_element(const isl::vec &vec2, int pos) const;
   inline isl::vec concat(isl::vec vec2) const;
   inline isl::vec drop_els(unsigned int pos, unsigned int n) const;
   inline isl::vec extend(unsigned int size) const;
   inline isl::val get_element_val(int pos) const;
   inline isl::vec insert_els(unsigned int pos, unsigned int n) const;
   inline isl::vec insert_zero_els(unsigned int pos, unsigned int n) const;
-  inline isl::boolean is_equal(const isl::vec &vec2) const;
+  inline bool is_equal(const isl::vec &vec2, isl::quota &quota) const;
   inline isl::vec mat_product(isl::mat mat) const;
   inline isl::vec move_els(unsigned int dst_col, unsigned int src_col, unsigned int n) const;
   inline isl::vec neg() const;
   inline isl::vec set_element_si(int pos, int v) const;
   inline isl::vec set_element_val(int pos, isl::val v) const;
   inline isl::vec set_si(int v) const;
   inline isl::vec set_val(isl::val v) const;
   inline int size() const;

 }
 
 isl::aff aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::boolean aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool aff::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean aff::is_cst() const
+bool aff::is_cst(isl::quota &quota) const
 {
   auto res = isl_aff_is_cst(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean aff::is_nan() const
+bool aff::is_nan(isl::quota &quota) const
 {
   auto res = isl_aff_is_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_set aff::le_basic_set(isl::aff aff2) const
 {
   auto res = isl_aff_le_basic_set(copy(), aff2.release());
   return manage(res);
 }
 

 }
 
 isl::aff aff::param_on_domain_space_id(isl::space space, isl::id id)
 {
   auto res = isl_aff_param_on_domain_space_id(space.release(), id.release());
   return manage(res);
 }
 
-isl::boolean aff::plain_is_equal(const isl::aff &aff2) const
+bool aff::plain_is_equal(const isl::aff &aff2, isl::quota &quota) const
 {
   auto res = isl_aff_plain_is_equal(get(), aff2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean aff::plain_is_zero() const
+bool aff::plain_is_zero(isl::quota &quota) const
 {
   auto res = isl_aff_plain_is_zero(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::aff aff::project_domain_on_params() const
 {
   auto res = isl_aff_project_domain_on_params(copy());
   return manage(res);
 }
 

 }
 
 isl::ast_expr ast_expr::gt(isl::ast_expr expr2) const
 {
   auto res = isl_ast_expr_gt(copy(), expr2.release());
   return manage(res);
 }
 
-isl::boolean ast_expr::is_equal(const isl::ast_expr &expr2) const
+bool ast_expr::is_equal(const isl::ast_expr &expr2, isl::quota &quota) const
 {
   auto res = isl_ast_expr_is_equal(get(), expr2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::ast_expr ast_expr::le(isl::ast_expr expr2) const
 {
   auto res = isl_ast_expr_le(copy(), expr2.release());
   return manage(res);
 }
 

 }
 
 isl::ast_expr ast_node::for_get_iterator() const
 {
   auto res = isl_ast_node_for_get_iterator(get());
   return manage(res);
 }
 
-isl::boolean ast_node::for_is_degenerate() const
+bool ast_node::for_is_degenerate(isl::quota &quota) const
 {
   auto res = isl_ast_node_for_is_degenerate(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::id ast_node::get_annotation() const
 {
   auto res = isl_ast_node_get_annotation(get());
   return manage(res);
 }
 

 }
 
 isl::ast_node ast_node::if_get_then() const
 {
   auto res = isl_ast_node_if_get_then(get());
   return manage(res);
 }
 
-isl::boolean ast_node::if_has_else() const
+bool ast_node::if_has_else(isl::quota &quota) const
 {
   auto res = isl_ast_node_if_has_else(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::id ast_node::mark_get_id() const
 {
   auto res = isl_ast_node_mark_get_id(get());
   return manage(res);
 }
 

 }
 
 isl::basic_map basic_map::apply_range(isl::basic_map bmap2) const
 {
   auto res = isl_basic_map_apply_range(copy(), bmap2.release());
   return manage(res);
 }
 
-isl::boolean basic_map::can_curry() const
+bool basic_map::can_curry(isl::quota &quota) const
 {
   auto res = isl_basic_map_can_curry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::can_uncurry() const
+bool basic_map::can_uncurry(isl::quota &quota) const
 {
   auto res = isl_basic_map_can_uncurry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::can_zip() const
+bool basic_map::can_zip(isl::quota &quota) const
 {
   auto res = isl_basic_map_can_zip(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_map basic_map::curry() const
 {
   auto res = isl_basic_map_curry(copy());
   return manage(res);
 }
 

 }
 
 isl::basic_map basic_map::flatten_range() const
 {
   auto res = isl_basic_map_flatten_range(copy());
   return manage(res);
 }
 
-isl::stat basic_map::foreach_constraint(const std::function<isl::stat(isl::constraint)> &fn) const
+void basic_map::foreach_constraint(const std::function<void(isl::constraint)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::constraint)> *func;
+    const std::function<void(isl::constraint)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_constraint *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_basic_map_foreach_constraint(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::basic_map basic_map::from_aff(isl::aff aff)
 {
   auto res = isl_basic_map_from_aff(aff.release());
   return manage(res);
 }
 

 }
 
 isl::basic_map basic_map::gist_domain(isl::basic_set context) const
 {
   auto res = isl_basic_map_gist_domain(copy(), context.release());
   return manage(res);
 }
 
-isl::boolean basic_map::has_dim_id(isl::dim type, unsigned int pos) const
+bool basic_map::has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_basic_map_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_map basic_map::identity(isl::space dim)
 {
   auto res = isl_basic_map_identity(dim.release());
   return manage(res);
 }
 
-isl::boolean basic_map::image_is_bounded() const
+bool basic_map::image_is_bounded(isl::quota &quota) const
 {
   auto res = isl_basic_map_image_is_bounded(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_map basic_map::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
 {
   auto res = isl_basic_map_insert_dims(copy(), static_cast<enum isl_dim_type>(type), pos, n);
   return manage(res);
 }
 

 }
 
 isl::basic_map basic_map::intersect_range(isl::basic_set bset) const
 {
   auto res = isl_basic_map_intersect_range(copy(), bset.release());
   return manage(res);
 }
 
-isl::boolean basic_map::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool basic_map::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_basic_map_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_disjoint(const isl::basic_map &bmap2) const
+bool basic_map::is_disjoint(const isl::basic_map &bmap2, isl::quota &quota) const
 {
   auto res = isl_basic_map_is_disjoint(get(), bmap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_empty() const
+bool basic_map::is_empty(isl::quota &quota) const
 {
   auto res = isl_basic_map_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_equal(const isl::basic_map &bmap2) const
+bool basic_map::is_equal(const isl::basic_map &bmap2, isl::quota &quota) const
 {
   auto res = isl_basic_map_is_equal(get(), bmap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_rational() const
+bool basic_map::is_rational(isl::quota &quota) const
 {
   auto res = isl_basic_map_is_rational(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_single_valued() const
+bool basic_map::is_single_valued(isl::quota &quota) const
 {
   auto res = isl_basic_map_is_single_valued(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_strict_subset(const isl::basic_map &bmap2) const
+bool basic_map::is_strict_subset(const isl::basic_map &bmap2, isl::quota &quota) const
 {
   auto res = isl_basic_map_is_strict_subset(get(), bmap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_subset(const isl::basic_map &bmap2) const
+bool basic_map::is_subset(const isl::basic_map &bmap2, isl::quota &quota) const
 {
   auto res = isl_basic_map_is_subset(get(), bmap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::is_universe() const
+bool basic_map::is_universe(isl::quota &quota) const
 {
   auto res = isl_basic_map_is_universe(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_map basic_map::less_at(isl::space dim, unsigned int pos)
 {
   auto res = isl_basic_map_less_at(dim.release(), pos);
   return manage(res);
 }
 

 }
 
 isl::val basic_map::plain_get_val_if_fixed(isl::dim type, unsigned int pos) const
 {
   auto res = isl_basic_map_plain_get_val_if_fixed(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-isl::boolean basic_map::plain_is_empty() const
+bool basic_map::plain_is_empty(isl::quota &quota) const
 {
   auto res = isl_basic_map_plain_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_map::plain_is_universe() const
+bool basic_map::plain_is_universe(isl::quota &quota) const
 {
   auto res = isl_basic_map_plain_is_universe(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_map basic_map::preimage_domain_multi_aff(isl::multi_aff ma) const
 {
   auto res = isl_basic_map_preimage_domain_multi_aff(copy(), ma.release());
   return manage(res);
 }
 

 }
 
 isl::basic_set basic_set::flatten() const
 {
   auto res = isl_basic_set_flatten(copy());
   return manage(res);
 }
 
-isl::stat basic_set::foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<isl::stat(isl::constraint, isl::constraint, isl::basic_set)> &fn) const
+void basic_set::foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<void(isl::constraint, isl::constraint, isl::basic_set)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::constraint, isl::constraint, isl::basic_set)> *func;
+    const std::function<void(isl::constraint, isl::constraint, isl::basic_set)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_constraint *arg_0, isl_constraint *arg_1, isl_basic_set *arg_2, void *arg_3) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_3);
-    stat ret = (*data->func)(isl::manage(arg_0), isl::manage(arg_1), isl::manage(arg_2));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0), isl::manage(arg_1), isl::manage(arg_2));
+    return isl_stat_ok;
   };
   auto res = isl_basic_set_foreach_bound_pair(get(), static_cast<enum isl_dim_type>(type), pos, fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
-isl::stat basic_set::foreach_constraint(const std::function<isl::stat(isl::constraint)> &fn) const
+void basic_set::foreach_constraint(const std::function<void(isl::constraint)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::constraint)> *func;
+    const std::function<void(isl::constraint)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_constraint *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_basic_set_foreach_constraint(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::basic_set basic_set::from_constraint(isl::constraint constraint)
 {
   auto res = isl_basic_set_from_constraint(constraint.release());
   return manage(res);
 }
 

 }
 
 isl::basic_set basic_set::intersect_params(isl::basic_set bset2) const
 {
   auto res = isl_basic_set_intersect_params(copy(), bset2.release());
   return manage(res);
 }
 
-isl::boolean basic_set::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool basic_set::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_basic_set_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::is_bounded() const
+bool basic_set::is_bounded(isl::quota &quota) const
 {
   auto res = isl_basic_set_is_bounded(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::is_disjoint(const isl::basic_set &bset2) const
+bool basic_set::is_disjoint(const isl::basic_set &bset2, isl::quota &quota) const
 {
   auto res = isl_basic_set_is_disjoint(get(), bset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::is_empty() const
+bool basic_set::is_empty(isl::quota &quota) const
 {
   auto res = isl_basic_set_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::is_equal(const isl::basic_set &bset2) const
+bool basic_set::is_equal(const isl::basic_set &bset2, isl::quota &quota) const
 {
   auto res = isl_basic_set_is_equal(get(), bset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 int basic_set::is_rational() const
 {
   auto res = isl_basic_set_is_rational(get());
   return res;
 }
 
-isl::boolean basic_set::is_subset(const isl::basic_set &bset2) const
+bool basic_set::is_subset(const isl::basic_set &bset2, isl::quota &quota) const
 {
   auto res = isl_basic_set_is_subset(get(), bset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::is_universe() const
+bool basic_set::is_universe(isl::quota &quota) const
 {
   auto res = isl_basic_set_is_universe(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::is_wrapping() const
+bool basic_set::is_wrapping(isl::quota &quota) const
 {
   auto res = isl_basic_set_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::set basic_set::lexmax() const
 {
   auto res = isl_basic_set_lexmax(copy());
   return manage(res);
 }
 

 }
 
 isl::basic_set basic_set::params() const
 {
   auto res = isl_basic_set_params(copy());
   return manage(res);
 }
 
-isl::boolean basic_set::plain_is_empty() const
+bool basic_set::plain_is_empty(isl::quota &quota) const
 {
   auto res = isl_basic_set_plain_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::plain_is_equal(const isl::basic_set &bset2) const
+bool basic_set::plain_is_equal(const isl::basic_set &bset2, isl::quota &quota) const
 {
   auto res = isl_basic_set_plain_is_equal(get(), bset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean basic_set::plain_is_universe() const
+bool basic_set::plain_is_universe(isl::quota &quota) const
 {
   auto res = isl_basic_set_plain_is_universe(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_set basic_set::positive_orthant(isl::space space)
 {
   auto res = isl_basic_set_positive_orthant(space.release());
   return manage(res);
 }
 

 }
 
 isl::space constraint::get_space() const
 {
   auto res = isl_constraint_get_space(get());
   return manage(res);
 }
 
-isl::boolean constraint::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool constraint::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_constraint_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 int constraint::is_div_constraint() const
 {
   auto res = isl_constraint_is_div_constraint(get());
   return res;
 }
 
-isl::boolean constraint::is_lower_bound(isl::dim type, unsigned int pos) const
+bool constraint::is_lower_bound(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_constraint_is_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean constraint::is_upper_bound(isl::dim type, unsigned int pos) const
+bool constraint::is_upper_bound(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_constraint_is_upper_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 int constraint::plain_cmp(const isl::constraint &c2) const
 {
   auto res = isl_constraint_plain_cmp(get(), c2.get());
   return res;
 }
 

 }
 
 isl::id_to_ast_expr id_to_ast_expr::drop(isl::id key) const
 {
   auto res = isl_id_to_ast_expr_drop(copy(), key.release());
   return manage(res);
 }
 
-isl::stat id_to_ast_expr::foreach(const std::function<isl::stat(isl::id, isl::ast_expr)> &fn) const
+void id_to_ast_expr::foreach(const std::function<void(isl::id, isl::ast_expr)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::id, isl::ast_expr)> *func;
+    const std::function<void(isl::id, isl::ast_expr)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_id *arg_0, isl_ast_expr *arg_1, void *arg_2) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_2);
-    stat ret = (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
+    return isl_stat_ok;
   };
   auto res = isl_id_to_ast_expr_foreach(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::ast_expr id_to_ast_expr::get(isl::id key) const
 {
   auto res = isl_id_to_ast_expr_get(get(), key.release());
   return manage(res);
 }
 
-isl::boolean id_to_ast_expr::has(const isl::id &key) const
+bool id_to_ast_expr::has(const isl::id &key, isl::quota &quota) const
 {
   auto res = isl_id_to_ast_expr_has(get(), key.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::id_to_ast_expr id_to_ast_expr::set(isl::id key, isl::ast_expr val) const
 {
   auto res = isl_id_to_ast_expr_set(copy(), key.release(), val.release());
   return manage(res);
 }
 

 }
 
 isl::space local_space::get_space() const
 {
   auto res = isl_local_space_get_space(get());
   return manage(res);
 }
 
-isl::boolean local_space::has_dim_id(isl::dim type, unsigned int pos) const
+bool local_space::has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_local_space_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean local_space::has_dim_name(isl::dim type, unsigned int pos) const
+bool local_space::has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_local_space_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::local_space local_space::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_local_space_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::local_space local_space::intersect(isl::local_space ls2) const
 {
   auto res = isl_local_space_intersect(copy(), ls2.release());
   return manage(res);
 }
 
-isl::boolean local_space::is_equal(const isl::local_space &ls2) const
+bool local_space::is_equal(const isl::local_space &ls2, isl::quota &quota) const
 {
   auto res = isl_local_space_is_equal(get(), ls2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean local_space::is_params() const
+bool local_space::is_params(isl::quota &quota) const
 {
   auto res = isl_local_space_is_params(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean local_space::is_set() const
+bool local_space::is_set(isl::quota &quota) const
 {
   auto res = isl_local_space_is_set(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::local_space local_space::range() const
 {
   auto res = isl_local_space_range(copy());
   return manage(res);
 }
 

 }
 
 isl::map map::apply_range(isl::map map2) const
 {
   auto res = isl_map_apply_range(copy(), map2.release());
   return manage(res);
 }
 
-isl::boolean map::can_curry() const
+bool map::can_curry(isl::quota &quota) const
 {
   auto res = isl_map_can_curry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::can_range_curry() const
+bool map::can_range_curry(isl::quota &quota) const
 {
   auto res = isl_map_can_range_curry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::can_uncurry() const
+bool map::can_uncurry(isl::quota &quota) const
 {
   auto res = isl_map_can_uncurry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::can_zip() const
+bool map::can_zip(isl::quota &quota) const
 {
   auto res = isl_map_can_zip(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map map::coalesce() const
 {
   auto res = isl_map_coalesce(copy());
   return manage(res);
 }
 

 }
 
 isl::map map::domain_factor_range() const
 {
   auto res = isl_map_domain_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean map::domain_is_wrapping() const
+bool map::domain_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_map_domain_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map map::domain_map() const
 {
   auto res = isl_map_domain_map(copy());
   return manage(res);
 }
 

 }
 
 isl::map map::floordiv_val(isl::val d) const
 {
   auto res = isl_map_floordiv_val(copy(), d.release());
   return manage(res);
 }
 
-isl::stat map::foreach_basic_map(const std::function<isl::stat(isl::basic_map)> &fn) const
+void map::foreach_basic_map(const std::function<void(isl::basic_map)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::basic_map)> *func;
+    const std::function<void(isl::basic_map)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_basic_map *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_map_foreach_basic_map(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::map map::from_aff(isl::aff aff)
 {
   auto res = isl_map_from_aff(aff.release());
   return manage(res);
 }
 

 }
 
 isl::map map::gist_range(isl::set context) const
 {
   auto res = isl_map_gist_range(copy(), context.release());
   return manage(res);
 }
 
-isl::boolean map::has_dim_id(isl::dim type, unsigned int pos) const
+bool map::has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_map_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::has_dim_name(isl::dim type, unsigned int pos) const
+bool map::has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_map_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::has_equal_space(const isl::map &map2) const
+bool map::has_equal_space(const isl::map &map2, isl::quota &quota) const
 {
   auto res = isl_map_has_equal_space(get(), map2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::has_tuple_id(isl::dim type) const
+bool map::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_map_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::has_tuple_name(isl::dim type) const
+bool map::has_tuple_name(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_map_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map map::identity(isl::space dim)
 {
   auto res = isl_map_identity(dim.release());
   return manage(res);
 }
 

 }
 
 isl::map map::intersect_range_factor_range(isl::map factor) const
 {
   auto res = isl_map_intersect_range_factor_range(copy(), factor.release());
   return manage(res);
 }
 
-isl::boolean map::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool map::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_map_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_bijective() const
+bool map::is_bijective(isl::quota &quota) const
 {
   auto res = isl_map_is_bijective(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_disjoint(const isl::map &map2) const
+bool map::is_disjoint(const isl::map &map2, isl::quota &quota) const
 {
   auto res = isl_map_is_disjoint(get(), map2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_empty() const
+bool map::is_empty(isl::quota &quota) const
 {
   auto res = isl_map_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_equal(const isl::map &map2) const
+bool map::is_equal(const isl::map &map2, isl::quota &quota) const
 {
   auto res = isl_map_is_equal(get(), map2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_identity() const
+bool map::is_identity(isl::quota &quota) const
 {
   auto res = isl_map_is_identity(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_injective() const
+bool map::is_injective(isl::quota &quota) const
 {
   auto res = isl_map_is_injective(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_product() const
+bool map::is_product(isl::quota &quota) const
 {
   auto res = isl_map_is_product(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_single_valued() const
+bool map::is_single_valued(isl::quota &quota) const
 {
   auto res = isl_map_is_single_valued(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_strict_subset(const isl::map &map2) const
+bool map::is_strict_subset(const isl::map &map2, isl::quota &quota) const
 {
   auto res = isl_map_is_strict_subset(get(), map2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::is_subset(const isl::map &map2) const
+bool map::is_subset(const isl::map &map2, isl::quota &quota) const
 {
   auto res = isl_map_is_subset(get(), map2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 int map::is_translation() const
 {
   auto res = isl_map_is_translation(get());
   return res;
 }
 

 }
 
 isl::val map::plain_get_val_if_fixed(isl::dim type, unsigned int pos) const
 {
   auto res = isl_map_plain_get_val_if_fixed(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-isl::boolean map::plain_is_empty() const
+bool map::plain_is_empty(isl::quota &quota) const
 {
   auto res = isl_map_plain_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::plain_is_equal(const isl::map &map2) const
+bool map::plain_is_equal(const isl::map &map2, isl::quota &quota) const
 {
   auto res = isl_map_plain_is_equal(get(), map2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::plain_is_injective() const
+bool map::plain_is_injective(isl::quota &quota) const
 {
   auto res = isl_map_plain_is_injective(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::plain_is_single_valued() const
+bool map::plain_is_single_valued(isl::quota &quota) const
 {
   auto res = isl_map_plain_is_single_valued(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean map::plain_is_universe() const
+bool map::plain_is_universe(isl::quota &quota) const
 {
   auto res = isl_map_plain_is_universe(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_map map::plain_unshifted_simple_hull() const
 {
   auto res = isl_map_plain_unshifted_simple_hull(copy());
   return manage(res);
 }
 

 }
 
 isl::map map::range_factor_range() const
 {
   auto res = isl_map_range_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean map::range_is_wrapping() const
+bool map::range_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_map_range_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map map::range_map() const
 {
   auto res = isl_map_range_map(copy());
   return manage(res);
 }
 

 }
 
 isl::val mat::get_element_val(int row, int col) const
 {
   auto res = isl_mat_get_element_val(get(), row, col);
   return manage(res);
 }
 
-isl::boolean mat::has_linearly_independent_rows(const isl::mat &mat2) const
+bool mat::has_linearly_independent_rows(const isl::mat &mat2, isl::quota &quota) const
 {
   auto res = isl_mat_has_linearly_independent_rows(get(), mat2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 int mat::initial_non_zero_cols() const
 {
   auto res = isl_mat_initial_non_zero_cols(get());
   return res;
 }
 

 }
 
 isl::mat mat::inverse_product(isl::mat right) const
 {
   auto res = isl_mat_inverse_product(copy(), right.release());
   return manage(res);
 }
 
-isl::boolean mat::is_equal(const isl::mat &mat2) const
+bool mat::is_equal(const isl::mat &mat2, isl::quota &quota) const
 {
   auto res = isl_mat_is_equal(get(), mat2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::mat mat::lin_to_aff() const
 {
   auto res = isl_mat_lin_to_aff(copy());
   return manage(res);
 }
 

 }
 
 isl::multi_aff multi_aff::gist_params(isl::set context) const
 {
   auto res = isl_multi_aff_gist_params(copy(), context.release());
   return manage(res);
 }
 
-isl::boolean multi_aff::has_tuple_id(isl::dim type) const
+bool multi_aff::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_multi_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_aff multi_aff::identity(isl::space space)
 {
   auto res = isl_multi_aff_identity(space.release());
   return manage(res);
 }
 
 isl::multi_aff multi_aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_multi_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::boolean multi_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool multi_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_multi_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean multi_aff::involves_nan() const
+bool multi_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_multi_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::set multi_aff::lex_ge_set(isl::multi_aff ma2) const
 {
   auto res = isl_multi_aff_lex_ge_set(copy(), ma2.release());
   return manage(res);
 }
 

 }
 
 int multi_aff::plain_cmp(const isl::multi_aff &multi2) const
 {
   auto res = isl_multi_aff_plain_cmp(get(), multi2.get());
   return res;
 }
 
-isl::boolean multi_aff::plain_is_equal(const isl::multi_aff &multi2) const
+bool multi_aff::plain_is_equal(const isl::multi_aff &multi2, isl::quota &quota) const
 {
   auto res = isl_multi_aff_plain_is_equal(get(), multi2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_aff multi_aff::product(isl::multi_aff multi2) const
 {
   auto res = isl_multi_aff_product(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::multi_aff multi_aff::range_factor_range() const
 {
   auto res = isl_multi_aff_range_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean multi_aff::range_is_wrapping() const
+bool multi_aff::range_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_multi_aff_range_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_aff multi_aff::range_map(isl::space space)
 {
   auto res = isl_multi_aff_range_map(space.release());
   return manage(res);
 }
 

 }
 
 isl::multi_pw_aff multi_pw_aff::gist_params(isl::set set) const
 {
   auto res = isl_multi_pw_aff_gist_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean multi_pw_aff::has_tuple_id(isl::dim type) const
+bool multi_pw_aff::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_pw_aff multi_pw_aff::identity(isl::space space)
 {
   auto res = isl_multi_pw_aff_identity(space.release());
   return manage(res);
 }
 

 }
 
 isl::multi_pw_aff multi_pw_aff::intersect_params(isl::set set) const
 {
   auto res = isl_multi_pw_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean multi_pw_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool multi_pw_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean multi_pw_aff::involves_nan() const
+bool multi_pw_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean multi_pw_aff::is_cst() const
+bool multi_pw_aff::is_cst(isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_is_cst(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean multi_pw_aff::is_equal(const isl::multi_pw_aff &mpa2) const
+bool multi_pw_aff::is_equal(const isl::multi_pw_aff &mpa2, isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_is_equal(get(), mpa2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map multi_pw_aff::lex_gt_map(isl::multi_pw_aff mpa2) const
 {
   auto res = isl_multi_pw_aff_lex_gt_map(copy(), mpa2.release());
   return manage(res);
 }
 

 }
 
 isl::multi_pw_aff multi_pw_aff::neg() const
 {
   auto res = isl_multi_pw_aff_neg(copy());
   return manage(res);
 }
 
-isl::boolean multi_pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+bool multi_pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2, isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_plain_is_equal(get(), multi2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_pw_aff multi_pw_aff::product(isl::multi_pw_aff multi2) const
 {
   auto res = isl_multi_pw_aff_product(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::multi_pw_aff multi_pw_aff::range_factor_range() const
 {
   auto res = isl_multi_pw_aff_range_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean multi_pw_aff::range_is_wrapping() const
+bool multi_pw_aff::range_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_multi_pw_aff_range_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_pw_aff multi_pw_aff::range_product(isl::multi_pw_aff multi2) const
 {
   auto res = isl_multi_pw_aff_range_product(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::gist_params(isl::set context) const
 {
   auto res = isl_multi_union_pw_aff_gist_params(copy(), context.release());
   return manage(res);
 }
 
-isl::boolean multi_union_pw_aff::has_tuple_id(isl::dim type) const
+bool multi_union_pw_aff::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_multi_union_pw_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::intersect_domain(isl::union_set uset) const
 {
   auto res = isl_multi_union_pw_aff_intersect_domain(copy(), uset.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::intersect_params(isl::set params) const
 {
   auto res = isl_multi_union_pw_aff_intersect_params(copy(), params.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::intersect_range(isl::set set) const
 {
   auto res = isl_multi_union_pw_aff_intersect_range(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean multi_union_pw_aff::involves_nan() const
+bool multi_union_pw_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_multi_union_pw_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::mod_multi_val(isl::multi_val mv) const
 {
   auto res = isl_multi_union_pw_aff_mod_multi_val(copy(), mv.release());
   return manage(res);
 }
 

 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::neg() const
 {
   auto res = isl_multi_union_pw_aff_neg(copy());
   return manage(res);
 }
 
-isl::boolean multi_union_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+bool multi_union_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2, isl::quota &quota) const
 {
   auto res = isl_multi_union_pw_aff_plain_is_equal(get(), multi2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::pullback(isl::union_pw_multi_aff upma) const
 {
   auto res = isl_multi_union_pw_aff_pullback_union_pw_multi_aff(copy(), upma.release());
   return manage(res);
 }
 

 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::range_factor_range() const
 {
   auto res = isl_multi_union_pw_aff_range_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean multi_union_pw_aff::range_is_wrapping() const
+bool multi_union_pw_aff::range_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_multi_union_pw_aff_range_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::range_product(isl::multi_union_pw_aff multi2) const
 {
   auto res = isl_multi_union_pw_aff_range_product(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::val multi_val::get_val(int pos) const
 {
   auto res = isl_multi_val_get_val(get(), pos);
   return manage(res);
 }
 
-isl::boolean multi_val::has_tuple_id(isl::dim type) const
+bool multi_val::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_multi_val_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_val multi_val::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_multi_val_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::boolean multi_val::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool multi_val::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_multi_val_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean multi_val::involves_nan() const
+bool multi_val::involves_nan(isl::quota &quota) const
 {
   auto res = isl_multi_val_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_val multi_val::mod_multi_val(isl::multi_val mv) const
 {
   auto res = isl_multi_val_mod_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::mod_val(isl::val v) const
 {
   auto res = isl_multi_val_mod_val(copy(), v.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::neg() const
 {
   auto res = isl_multi_val_neg(copy());
   return manage(res);
 }
 
-isl::boolean multi_val::plain_is_equal(const isl::multi_val &multi2) const
+bool multi_val::plain_is_equal(const isl::multi_val &multi2, isl::quota &quota) const
 {
   auto res = isl_multi_val_plain_is_equal(get(), multi2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_val multi_val::product(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_product(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::multi_val multi_val::range_factor_range() const
 {
   auto res = isl_multi_val_range_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean multi_val::range_is_wrapping() const
+bool multi_val::range_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_multi_val_range_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::multi_val multi_val::range_product(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_range_product(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::pw_aff pw_aff::floor() const
 {
   auto res = isl_pw_aff_floor(copy());
   return manage(res);
 }
 
-isl::stat pw_aff::foreach_piece(const std::function<isl::stat(isl::set, isl::aff)> &fn) const
+void pw_aff::foreach_piece(const std::function<void(isl::set, isl::aff)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::set, isl::aff)> *func;
+    const std::function<void(isl::set, isl::aff)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_set *arg_0, isl_aff *arg_1, void *arg_2) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_2);
-    stat ret = (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
+    return isl_stat_ok;
   };
   auto res = isl_pw_aff_foreach_piece(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::pw_aff pw_aff::from_range() const
 {
   auto res = isl_pw_aff_from_range(copy());
   return manage(res);
 }
 

 }
 
 isl::set pw_aff::gt_set(isl::pw_aff pwaff2) const
 {
   auto res = isl_pw_aff_gt_set(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl::boolean pw_aff::has_dim_id(isl::dim type, unsigned int pos) const
+bool pw_aff::has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_pw_aff_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_aff::has_tuple_id(isl::dim type) const
+bool pw_aff::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_pw_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_aff pw_aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_pw_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::pw_aff pw_aff::intersect_domain(isl::set set) const
 {
   auto res = isl_pw_aff_intersect_domain(copy(), set.release());
   return manage(res);
 }
 
 isl::pw_aff pw_aff::intersect_params(isl::set set) const
 {
   auto res = isl_pw_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean pw_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool pw_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_pw_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_aff::involves_nan() const
+bool pw_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_pw_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_aff::is_cst() const
+bool pw_aff::is_cst(isl::quota &quota) const
 {
   auto res = isl_pw_aff_is_cst(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_aff::is_empty() const
+bool pw_aff::is_empty(isl::quota &quota) const
 {
   auto res = isl_pw_aff_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_aff::is_equal(const isl::pw_aff &pa2) const
+bool pw_aff::is_equal(const isl::pw_aff &pa2, isl::quota &quota) const
 {
   auto res = isl_pw_aff_is_equal(get(), pa2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::set pw_aff::le_set(isl::pw_aff pwaff2) const
 {
   auto res = isl_pw_aff_le_set(copy(), pwaff2.release());
   return manage(res);
 }
 

 }
 
 int pw_aff::plain_cmp(const isl::pw_aff &pa2) const
 {
   auto res = isl_pw_aff_plain_cmp(get(), pa2.get());
   return res;
 }
 
-isl::boolean pw_aff::plain_is_equal(const isl::pw_aff &pwaff2) const
+bool pw_aff::plain_is_equal(const isl::pw_aff &pwaff2, isl::quota &quota) const
 {
   auto res = isl_pw_aff_plain_is_equal(get(), pwaff2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::set pw_aff::pos_set() const
 {
   auto res = isl_pw_aff_pos_set(copy());
   return manage(res);
 }
 

 }
 
 isl::pw_multi_aff pw_multi_aff::flat_range_product(isl::pw_multi_aff pma2) const
 {
   auto res = isl_pw_multi_aff_flat_range_product(copy(), pma2.release());
   return manage(res);
 }
 
-isl::stat pw_multi_aff::foreach_piece(const std::function<isl::stat(isl::set, isl::multi_aff)> &fn) const
+void pw_multi_aff::foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::set, isl::multi_aff)> *func;
+    const std::function<void(isl::set, isl::multi_aff)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_set *arg_0, isl_multi_aff *arg_1, void *arg_2) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_2);
-    stat ret = (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
+    return isl_stat_ok;
   };
   auto res = isl_pw_multi_aff_foreach_piece(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::pw_multi_aff pw_multi_aff::from_domain(isl::set set)
 {
   auto res = isl_pw_multi_aff_from_domain(set.release());
   return manage(res);
 }
 

 }
 
 isl::pw_multi_aff pw_multi_aff::gist_params(isl::set set) const
 {
   auto res = isl_pw_multi_aff_gist_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean pw_multi_aff::has_tuple_id(isl::dim type) const
+bool pw_multi_aff::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_pw_multi_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_multi_aff::has_tuple_name(isl::dim type) const
+bool pw_multi_aff::has_tuple_name(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_pw_multi_aff_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_multi_aff pw_multi_aff::identity(isl::space space)
 {
   auto res = isl_pw_multi_aff_identity(space.release());
   return manage(res);
 }
 
 isl::pw_multi_aff pw_multi_aff::intersect_domain(isl::set set) const
 {
   auto res = isl_pw_multi_aff_intersect_domain(copy(), set.release());
   return manage(res);
 }
 
 isl::pw_multi_aff pw_multi_aff::intersect_params(isl::set set) const
 {
   auto res = isl_pw_multi_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean pw_multi_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool pw_multi_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_pw_multi_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_multi_aff::involves_nan() const
+bool pw_multi_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_pw_multi_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_multi_aff::is_equal(const isl::pw_multi_aff &pma2) const
+bool pw_multi_aff::is_equal(const isl::pw_multi_aff &pma2, isl::quota &quota) const
 {
   auto res = isl_pw_multi_aff_is_equal(get(), pma2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_multi_aff pw_multi_aff::multi_val_on_domain(isl::set domain, isl::multi_val mv)
 {
   auto res = isl_pw_multi_aff_multi_val_on_domain(domain.release(), mv.release());
   return manage(res);
 }
 
 int pw_multi_aff::n_piece() const
 {
   auto res = isl_pw_multi_aff_n_piece(get());
   return res;
 }
 
 isl::pw_multi_aff pw_multi_aff::neg() const
 {
   auto res = isl_pw_multi_aff_neg(copy());
   return manage(res);
 }
 
-isl::boolean pw_multi_aff::plain_is_equal(const isl::pw_multi_aff &pma2) const
+bool pw_multi_aff::plain_is_equal(const isl::pw_multi_aff &pma2, isl::quota &quota) const
 {
   auto res = isl_pw_multi_aff_plain_is_equal(get(), pma2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_multi_aff pw_multi_aff::product(isl::pw_multi_aff pma2) const
 {
   auto res = isl_pw_multi_aff_product(copy(), pma2.release());
   return manage(res);
 }
 

 }
 
 isl::pw_qpolynomial pw_qpolynomial::fix_val(isl::dim type, unsigned int n, isl::val v) const
 {
   auto res = isl_pw_qpolynomial_fix_val(copy(), static_cast<enum isl_dim_type>(type), n, v.release());
   return manage(res);
 }
 
-isl::stat pw_qpolynomial::foreach_piece(const std::function<isl::stat(isl::set, isl::qpolynomial)> &fn) const
+void pw_qpolynomial::foreach_piece(const std::function<void(isl::set, isl::qpolynomial)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::set, isl::qpolynomial)> *func;
+    const std::function<void(isl::set, isl::qpolynomial)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_set *arg_0, isl_qpolynomial *arg_1, void *arg_2) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_2);
-    stat ret = (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
+    return isl_stat_ok;
   };
   auto res = isl_pw_qpolynomial_foreach_piece(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::pw_qpolynomial pw_qpolynomial::from_pw_aff(isl::pw_aff pwaff)
 {
   auto res = isl_pw_qpolynomial_from_pw_aff(pwaff.release());
   return manage(res);
 }
 

 }
 
 isl::pw_qpolynomial pw_qpolynomial::gist_params(isl::set context) const
 {
   auto res = isl_pw_qpolynomial_gist_params(copy(), context.release());
   return manage(res);
 }
 
-isl::boolean pw_qpolynomial::has_equal_space(const isl::pw_qpolynomial &pwqp2) const
+bool pw_qpolynomial::has_equal_space(const isl::pw_qpolynomial &pwqp2, isl::quota &quota) const
 {
   auto res = isl_pw_qpolynomial_has_equal_space(get(), pwqp2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_qpolynomial pw_qpolynomial::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_pw_qpolynomial_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::pw_qpolynomial pw_qpolynomial::intersect_domain(isl::set set) const
 {
   auto res = isl_pw_qpolynomial_intersect_domain(copy(), set.release());
   return manage(res);
 }
 
 isl::pw_qpolynomial pw_qpolynomial::intersect_params(isl::set set) const
 {
   auto res = isl_pw_qpolynomial_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean pw_qpolynomial::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool pw_qpolynomial::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_pw_qpolynomial_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_qpolynomial::involves_nan() const
+bool pw_qpolynomial::involves_nan(isl::quota &quota) const
 {
   auto res = isl_pw_qpolynomial_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean pw_qpolynomial::is_zero() const
+bool pw_qpolynomial::is_zero(isl::quota &quota) const
 {
   auto res = isl_pw_qpolynomial_is_zero(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::val pw_qpolynomial::max() const
 {
   auto res = isl_pw_qpolynomial_max(copy());
   return manage(res);
 }
 

 }
 
 isl::pw_qpolynomial pw_qpolynomial::neg() const
 {
   auto res = isl_pw_qpolynomial_neg(copy());
   return manage(res);
 }
 
-isl::boolean pw_qpolynomial::plain_is_equal(const isl::pw_qpolynomial &pwqp2) const
+bool pw_qpolynomial::plain_is_equal(const isl::pw_qpolynomial &pwqp2, isl::quota &quota) const
 {
   auto res = isl_pw_qpolynomial_plain_is_equal(get(), pwqp2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_qpolynomial pw_qpolynomial::pow(unsigned int exponent) const
 {
   auto res = isl_pw_qpolynomial_pow(copy(), exponent);
   return manage(res);
 }
 

 }
 
 isl::qpolynomial qpolynomial::align_params(isl::space model) const
 {
   auto res = isl_qpolynomial_align_params(copy(), model.release());
   return manage(res);
 }
 
-isl::stat qpolynomial::as_polynomial_on_domain(const isl::basic_set &bset, const std::function<isl::stat(isl::basic_set, isl::qpolynomial)> &fn) const
+void qpolynomial::as_polynomial_on_domain(const isl::basic_set &bset, const std::function<void(isl::basic_set, isl::qpolynomial)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::basic_set, isl::qpolynomial)> *func;
+    const std::function<void(isl::basic_set, isl::qpolynomial)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_basic_set *arg_0, isl_qpolynomial *arg_1, void *arg_2) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_2);
-    stat ret = (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0), isl::manage(arg_1));
+    return isl_stat_ok;
   };
   auto res = isl_qpolynomial_as_polynomial_on_domain(get(), bset.get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 unsigned int qpolynomial::dim(isl::dim type) const
 {
   auto res = isl_qpolynomial_dim(get(), static_cast<enum isl_dim_type>(type));
   return res;
 }
 
 isl::qpolynomial qpolynomial::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_qpolynomial_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::val qpolynomial::eval(isl::point pnt) const
 {
   auto res = isl_qpolynomial_eval(copy(), pnt.release());
   return manage(res);
 }
 
-isl::stat qpolynomial::foreach_term(const std::function<isl::stat(isl::term)> &fn) const
+void qpolynomial::foreach_term(const std::function<void(isl::term)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::term)> *func;
+    const std::function<void(isl::term)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_term *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_qpolynomial_foreach_term(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::qpolynomial qpolynomial::from_aff(isl::aff aff)
 {
   auto res = isl_qpolynomial_from_aff(aff.release());
   return manage(res);
 }
 

 }
 
 isl::qpolynomial qpolynomial::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_qpolynomial_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::boolean qpolynomial::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool qpolynomial::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_qpolynomial_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean qpolynomial::is_infty() const
+bool qpolynomial::is_infty(isl::quota &quota) const
 {
   auto res = isl_qpolynomial_is_infty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean qpolynomial::is_nan() const
+bool qpolynomial::is_nan(isl::quota &quota) const
 {
   auto res = isl_qpolynomial_is_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean qpolynomial::is_neginfty() const
+bool qpolynomial::is_neginfty(isl::quota &quota) const
 {
   auto res = isl_qpolynomial_is_neginfty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean qpolynomial::is_zero() const
+bool qpolynomial::is_zero(isl::quota &quota) const
 {
   auto res = isl_qpolynomial_is_zero(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::qpolynomial qpolynomial::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
 {
   auto res = isl_qpolynomial_move_dims(copy(), static_cast<enum isl_dim_type>(dst_type), dst_pos, static_cast<enum isl_dim_type>(src_type), src_pos, n);
   return manage(res);
 }
 

 }
 
 isl::qpolynomial qpolynomial::one_on_domain(isl::space dim)
 {
   auto res = isl_qpolynomial_one_on_domain(dim.release());
   return manage(res);
 }
 
-isl::boolean qpolynomial::plain_is_equal(const isl::qpolynomial &qp2) const
+bool qpolynomial::plain_is_equal(const isl::qpolynomial &qp2, isl::quota &quota) const
 {
   auto res = isl_qpolynomial_plain_is_equal(get(), qp2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::qpolynomial qpolynomial::pow(unsigned int power) const
 {
   auto res = isl_qpolynomial_pow(copy(), power);
   return manage(res);
 }
 

 }
 
 isl::schedule schedule::intersect_domain(isl::union_set domain) const
 {
   auto res = isl_schedule_intersect_domain(copy(), domain.release());
   return manage(res);
 }
 
-isl::boolean schedule::plain_is_equal(const isl::schedule &schedule2) const
+bool schedule::plain_is_equal(const isl::schedule &schedule2, isl::quota &quota) const
 {
   auto res = isl_schedule_plain_is_equal(get(), schedule2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::schedule schedule::pullback(isl::union_pw_multi_aff upma) const
 {
   auto res = isl_schedule_pullback_union_pw_multi_aff(copy(), upma.release());
   return manage(res);
 }
 

 }
 
 isl::schedule_node schedule_node::ancestor(int generation) const
 {
   auto res = isl_schedule_node_ancestor(copy(), generation);
   return manage(res);
 }
 
-isl::boolean schedule_node::band_member_get_coincident(int pos) const
+bool schedule_node::band_member_get_coincident(int pos, isl::quota &quota) const
 {
   auto res = isl_schedule_node_band_member_get_coincident(get(), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::schedule_node schedule_node::band_member_set_coincident(int pos, int coincident) const
 {
   auto res = isl_schedule_node_band_member_set_coincident(copy(), pos, coincident);
   return manage(res);
 }
 

 }
 
 isl::schedule_node schedule_node::first_child() const
 {
   auto res = isl_schedule_node_first_child(copy());
   return manage(res);
 }
 
-isl::stat schedule_node::foreach_ancestor_top_down(const std::function<isl::stat(isl::schedule_node)> &fn) const
+void schedule_node::foreach_ancestor_top_down(const std::function<void(isl::schedule_node)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::schedule_node)> *func;
+    const std::function<void(isl::schedule_node)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_schedule_node *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_schedule_node_foreach_ancestor_top_down(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::schedule_node schedule_node::from_domain(isl::union_set domain)
 {
   auto res = isl_schedule_node_from_domain(domain.release());
   return manage(res);
 }
 

 }
 
 isl::set schedule_node::guard_get_guard() const
 {
   auto res = isl_schedule_node_guard_get_guard(get());
   return manage(res);
 }
 
-isl::boolean schedule_node::has_children() const
+bool schedule_node::has_children(isl::quota &quota) const
 {
   auto res = isl_schedule_node_has_children(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean schedule_node::has_next_sibling() const
+bool schedule_node::has_next_sibling(isl::quota &quota) const
 {
   auto res = isl_schedule_node_has_next_sibling(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean schedule_node::has_parent() const
+bool schedule_node::has_parent(isl::quota &quota) const
 {
   auto res = isl_schedule_node_has_parent(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean schedule_node::has_previous_sibling() const
+bool schedule_node::has_previous_sibling(isl::quota &quota) const
 {
   auto res = isl_schedule_node_has_previous_sibling(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::schedule_node schedule_node::insert_context(isl::set context) const
 {
   auto res = isl_schedule_node_insert_context(copy(), context.release());
   return manage(res);
 }
 

 }
 
 isl::schedule_node schedule_node::insert_set(isl::union_set_list filters) const
 {
   auto res = isl_schedule_node_insert_set(copy(), filters.release());
   return manage(res);
 }
 
-isl::boolean schedule_node::is_equal(const isl::schedule_node &node2) const
+bool schedule_node::is_equal(const isl::schedule_node &node2, isl::quota &quota) const
 {
   auto res = isl_schedule_node_is_equal(get(), node2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean schedule_node::is_subtree_anchored() const
+bool schedule_node::is_subtree_anchored(isl::quota &quota) const
 {
   auto res = isl_schedule_node_is_subtree_anchored(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::id schedule_node::mark_get_id() const
 {
   auto res = isl_schedule_node_mark_get_id(get());
   return manage(res);
 }
 

 }
 
 unsigned int set::dim(isl::dim type) const
 {
   auto res = isl_set_dim(get(), static_cast<enum isl_dim_type>(type));
   return res;
 }
 
-isl::boolean set::dim_has_any_lower_bound(isl::dim type, unsigned int pos) const
+bool set::dim_has_any_lower_bound(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_dim_has_any_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::dim_has_any_upper_bound(isl::dim type, unsigned int pos) const
+bool set::dim_has_any_upper_bound(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_dim_has_any_upper_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::dim_has_lower_bound(isl::dim type, unsigned int pos) const
+bool set::dim_has_lower_bound(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_dim_has_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::dim_has_upper_bound(isl::dim type, unsigned int pos) const
+bool set::dim_has_upper_bound(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_dim_has_upper_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::dim_is_bounded(isl::dim type, unsigned int pos) const
+bool set::dim_is_bounded(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_dim_is_bounded(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::pw_aff set::dim_max(int pos) const
 {
   auto res = isl_set_dim_max(copy(), pos);
   return manage(res);
 }
 

 }
 
 int set::follows_at(const isl::set &set2, int pos) const
 {
   auto res = isl_set_follows_at(get(), set2.get(), pos);
   return res;
 }
 
-isl::stat set::foreach_basic_set(const std::function<isl::stat(isl::basic_set)> &fn) const
+void set::foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::basic_set)> *func;
+    const std::function<void(isl::basic_set)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_basic_set *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_set_foreach_basic_set(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
-isl::stat set::foreach_point(const std::function<isl::stat(isl::point)> &fn) const
+void set::foreach_point(const std::function<void(isl::point)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::point)> *func;
+    const std::function<void(isl::point)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_point *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_set_foreach_point(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::set set::from_multi_pw_aff(isl::multi_pw_aff mpa)
 {
   auto res = isl_set_from_multi_pw_aff(mpa.release());
   return manage(res);
 }
 

 }
 
 isl::set set::gist_params(isl::set context) const
 {
   auto res = isl_set_gist_params(copy(), context.release());
   return manage(res);
 }
 
-isl::boolean set::has_dim_id(isl::dim type, unsigned int pos) const
+bool set::has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::has_dim_name(isl::dim type, unsigned int pos) const
+bool set::has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_set_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::has_equal_space(const isl::set &set2) const
+bool set::has_equal_space(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_has_equal_space(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::has_tuple_id() const
+bool set::has_tuple_id(isl::quota &quota) const
 {
   auto res = isl_set_has_tuple_id(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::has_tuple_name() const
+bool set::has_tuple_name(isl::quota &quota) const
 {
   auto res = isl_set_has_tuple_name(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map set::identity() const
 {
   auto res = isl_set_identity(copy());
   return manage(res);
 }
 

 }
 
 isl::set set::intersect_params(isl::set params) const
 {
   auto res = isl_set_intersect_params(copy(), params.release());
   return manage(res);
 }
 
-isl::boolean set::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool set::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_set_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_bounded() const
+bool set::is_bounded(isl::quota &quota) const
 {
   auto res = isl_set_is_bounded(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_box() const
+bool set::is_box(isl::quota &quota) const
 {
   auto res = isl_set_is_box(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_disjoint(const isl::set &set2) const
+bool set::is_disjoint(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_is_disjoint(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_empty() const
+bool set::is_empty(isl::quota &quota) const
 {
   auto res = isl_set_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_equal(const isl::set &set2) const
+bool set::is_equal(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_is_equal(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_params() const
+bool set::is_params(isl::quota &quota) const
 {
   auto res = isl_set_is_params(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_singleton() const
+bool set::is_singleton(isl::quota &quota) const
 {
   auto res = isl_set_is_singleton(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_strict_subset(const isl::set &set2) const
+bool set::is_strict_subset(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_is_strict_subset(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_subset(const isl::set &set2) const
+bool set::is_subset(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_is_subset(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::is_wrapping() const
+bool set::is_wrapping(isl::quota &quota) const
 {
   auto res = isl_set_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::map set::lex_ge_set(isl::set set2) const
 {
   auto res = isl_set_lex_ge_set(copy(), set2.release());
   return manage(res);
 }
 

 }
 
 isl::val set::plain_get_val_if_fixed(isl::dim type, unsigned int pos) const
 {
   auto res = isl_set_plain_get_val_if_fixed(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-isl::boolean set::plain_is_disjoint(const isl::set &set2) const
+bool set::plain_is_disjoint(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_plain_is_disjoint(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::plain_is_empty() const
+bool set::plain_is_empty(isl::quota &quota) const
 {
   auto res = isl_set_plain_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::plain_is_equal(const isl::set &set2) const
+bool set::plain_is_equal(const isl::set &set2, isl::quota &quota) const
 {
   auto res = isl_set_plain_is_equal(get(), set2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean set::plain_is_universe() const
+bool set::plain_is_universe(isl::quota &quota) const
 {
   auto res = isl_set_plain_is_universe(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::basic_set set::plain_unshifted_simple_hull() const
 {
   auto res = isl_set_plain_unshifted_simple_hull(copy());
   return manage(res);
 }
 

 }
 
 isl::space space::align_params(isl::space dim2) const
 {
   auto res = isl_space_align_params(copy(), dim2.release());
   return manage(res);
 }
 
-isl::boolean space::can_curry() const
+bool space::can_curry(isl::quota &quota) const
 {
   auto res = isl_space_can_curry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::can_range_curry() const
+bool space::can_range_curry(isl::quota &quota) const
 {
   auto res = isl_space_can_range_curry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::can_uncurry() const
+bool space::can_uncurry(isl::quota &quota) const
 {
   auto res = isl_space_can_uncurry(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::can_zip() const
+bool space::can_zip(isl::quota &quota) const
 {
   auto res = isl_space_can_zip(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::space space::curry() const
 {
   auto res = isl_space_curry(copy());
   return manage(res);
 }
 

 }
 
 isl::space space::domain_factor_range() const
 {
   auto res = isl_space_domain_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean space::domain_is_wrapping() const
+bool space::domain_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_space_domain_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::space space::domain_map() const
 {
   auto res = isl_space_domain_map(copy());
   return manage(res);
 }
 

 
 std::string space::get_tuple_name(isl::dim type) const
 {
   auto res = isl_space_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
   std::string tmp(res);
   return tmp;
 }
 
-isl::boolean space::has_dim_id(isl::dim type, unsigned int pos) const
+bool space::has_dim_id(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_space_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::has_dim_name(isl::dim type, unsigned int pos) const
+bool space::has_dim_name(isl::dim type, unsigned int pos, isl::quota &quota) const
 {
   auto res = isl_space_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::has_equal_params(const isl::space &space2) const
+bool space::has_equal_params(const isl::space &space2, isl::quota &quota) const
 {
   auto res = isl_space_has_equal_params(get(), space2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::has_equal_tuples(const isl::space &space2) const
+bool space::has_equal_tuples(const isl::space &space2, isl::quota &quota) const
 {
   auto res = isl_space_has_equal_tuples(get(), space2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::has_tuple_id(isl::dim type) const
+bool space::has_tuple_id(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_space_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::has_tuple_name(isl::dim type) const
+bool space::has_tuple_name(isl::dim type, isl::quota &quota) const
 {
   auto res = isl_space_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::space space::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
 {
   auto res = isl_space_insert_dims(copy(), static_cast<enum isl_dim_type>(type), pos, n);
   return manage(res);
 }
 
-isl::boolean space::is_domain(const isl::space &space2) const
+bool space::is_domain(const isl::space &space2, isl::quota &quota) const
 {
   auto res = isl_space_is_domain(get(), space2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_equal(const isl::space &space2) const
+bool space::is_equal(const isl::space &space2, isl::quota &quota) const
 {
   auto res = isl_space_is_equal(get(), space2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_map() const
+bool space::is_map(isl::quota &quota) const
 {
   auto res = isl_space_is_map(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_params() const
+bool space::is_params(isl::quota &quota) const
 {
   auto res = isl_space_is_params(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_product() const
+bool space::is_product(isl::quota &quota) const
 {
   auto res = isl_space_is_product(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_range(const isl::space &space2) const
+bool space::is_range(const isl::space &space2, isl::quota &quota) const
 {
   auto res = isl_space_is_range(get(), space2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_set() const
+bool space::is_set(isl::quota &quota) const
 {
   auto res = isl_space_is_set(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean space::is_wrapping() const
+bool space::is_wrapping(isl::quota &quota) const
 {
   auto res = isl_space_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::space space::join(isl::space right) const
 {
   auto res = isl_space_join(copy(), right.release());
   return manage(res);
 }
 

 }
 
 isl::space space::range_factor_range() const
 {
   auto res = isl_space_range_factor_range(copy());
   return manage(res);
 }
 
-isl::boolean space::range_is_wrapping() const
+bool space::range_is_wrapping(isl::quota &quota) const
 {
   auto res = isl_space_range_is_wrapping(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::space space::range_map() const
 {
   auto res = isl_space_range_map(copy());
   return manage(res);
 }
 

 }
 
 isl::space space::set_tuple_name(isl::dim type, const std::string &s) const
 {
   auto res = isl_space_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
   return manage(res);
 }
 
-isl::boolean space::tuple_is_equal(isl::dim type1, const isl::space &space2, isl::dim type2) const
+bool space::tuple_is_equal(isl::dim type1, const isl::space &space2, isl::dim type2, isl::quota &quota) const
 {
   auto res = isl_space_tuple_is_equal(get(), static_cast<enum isl_dim_type>(type1), space2.get(), static_cast<enum isl_dim_type>(type2));
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::space space::uncurry() const
 {
   auto res = isl_space_uncurry(copy());
   return manage(res);
 }
 

 }
 
 isl::union_map union_map::coalesce() const
 {
   auto res = isl_union_map_coalesce(copy());
   return manage(res);
 }
 
-isl::boolean union_map::contains(const isl::space &space) const
+bool union_map::contains(const isl::space &space, isl::quota &quota) const
 {
   auto res = isl_union_map_contains(get(), space.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_map union_map::curry() const
 {
   auto res = isl_union_map_curry(copy());
   return manage(res);
 }
 

 }
 
 isl::union_map union_map::flat_range_product(isl::union_map umap2) const
 {
   auto res = isl_union_map_flat_range_product(copy(), umap2.release());
   return manage(res);
 }
 
-isl::stat union_map::foreach_map(const std::function<isl::stat(isl::map)> &fn) const
+void union_map::foreach_map(const std::function<void(isl::map)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::map)> *func;
+    const std::function<void(isl::map)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_map *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_union_map_foreach_map(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::union_map union_map::from(isl::union_pw_multi_aff upma)
 {
   auto res = isl_union_map_from_union_pw_multi_aff(upma.release());
   return manage(res);
 }
 

 }
 
 isl::union_map union_map::intersect_range_factor_range(isl::union_map factor) const
 {
   auto res = isl_union_map_intersect_range_factor_range(copy(), factor.release());
   return manage(res);
 }
 
-isl::boolean union_map::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+bool union_map::involves_dims(isl::dim type, unsigned int first, unsigned int n, isl::quota &quota) const
 {
   auto res = isl_union_map_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_bijective() const
+bool union_map::is_bijective(isl::quota &quota) const
 {
   auto res = isl_union_map_is_bijective(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_disjoint(const isl::union_map &umap2) const
+bool union_map::is_disjoint(const isl::union_map &umap2, isl::quota &quota) const
 {
   auto res = isl_union_map_is_disjoint(get(), umap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_empty() const
+bool union_map::is_empty(isl::quota &quota) const
 {
   auto res = isl_union_map_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_equal(const isl::union_map &umap2) const
+bool union_map::is_equal(const isl::union_map &umap2, isl::quota &quota) const
 {
   auto res = isl_union_map_is_equal(get(), umap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_identity() const
+bool union_map::is_identity(isl::quota &quota) const
 {
   auto res = isl_union_map_is_identity(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_injective() const
+bool union_map::is_injective(isl::quota &quota) const
 {
   auto res = isl_union_map_is_injective(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_single_valued() const
+bool union_map::is_single_valued(isl::quota &quota) const
 {
   auto res = isl_union_map_is_single_valued(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_strict_subset(const isl::union_map &umap2) const
+bool union_map::is_strict_subset(const isl::union_map &umap2, isl::quota &quota) const
 {
   auto res = isl_union_map_is_strict_subset(get(), umap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::is_subset(const isl::union_map &umap2) const
+bool union_map::is_subset(const isl::union_map &umap2, isl::quota &quota) const
 {
   auto res = isl_union_map_is_subset(get(), umap2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_map union_map::lex_ge_union_map(isl::union_map umap2) const
 {
   auto res = isl_union_map_lex_ge_union_map(copy(), umap2.release());
   return manage(res);
 }
 

 }
 
 isl::set union_map::params() const
 {
   auto res = isl_union_map_params(copy());
   return manage(res);
 }
 
-isl::boolean union_map::plain_is_empty() const
+bool union_map::plain_is_empty(isl::quota &quota) const
 {
   auto res = isl_union_map_plain_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_map::plain_is_injective() const
+bool union_map::plain_is_injective(isl::quota &quota) const
 {
   auto res = isl_union_map_plain_is_injective(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_map union_map::polyhedral_hull() const
 {
   auto res = isl_union_map_polyhedral_hull(copy());
   return manage(res);
 }
 

 }
 
 isl::union_pw_aff union_pw_aff::floor() const
 {
   auto res = isl_union_pw_aff_floor(copy());
   return manage(res);
 }
 
-isl::stat union_pw_aff::foreach_pw_aff(const std::function<isl::stat(isl::pw_aff)> &fn) const
+void union_pw_aff::foreach_pw_aff(const std::function<void(isl::pw_aff)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::pw_aff)> *func;
+    const std::function<void(isl::pw_aff)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_pw_aff *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_union_pw_aff_foreach_pw_aff(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::space union_pw_aff::get_space() const
 {
   auto res = isl_union_pw_aff_get_space(get());
   return manage(res);
 }
 

 }
 
 isl::union_pw_aff union_pw_aff::intersect_params(isl::set set) const
 {
   auto res = isl_union_pw_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean union_pw_aff::involves_nan() const
+bool union_pw_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_union_pw_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_pw_aff union_pw_aff::mod_val(isl::val f) const
 {
   auto res = isl_union_pw_aff_mod_val(copy(), f.release());
   return manage(res);
 }
 

 }
 
 isl::union_pw_aff union_pw_aff::param_on_domain_id(isl::union_set domain, isl::id id)
 {
   auto res = isl_union_pw_aff_param_on_domain_id(domain.release(), id.release());
   return manage(res);
 }
 
-isl::boolean union_pw_aff::plain_is_equal(const isl::union_pw_aff &upa2) const
+bool union_pw_aff::plain_is_equal(const isl::union_pw_aff &upa2, isl::quota &quota) const
 {
   auto res = isl_union_pw_aff_plain_is_equal(get(), upa2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_pw_aff union_pw_aff::pullback(isl::union_pw_multi_aff upma) const
 {
   auto res = isl_union_pw_aff_pullback_union_pw_multi_aff(copy(), upma.release());
   return manage(res);
 }
 

 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::flat_range_product(isl::union_pw_multi_aff upma2) const
 {
   auto res = isl_union_pw_multi_aff_flat_range_product(copy(), upma2.release());
   return manage(res);
 }
 
-isl::stat union_pw_multi_aff::foreach_pw_multi_aff(const std::function<isl::stat(isl::pw_multi_aff)> &fn) const
+void union_pw_multi_aff::foreach_pw_multi_aff(const std::function<void(isl::pw_multi_aff)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::pw_multi_aff)> *func;
+    const std::function<void(isl::pw_multi_aff)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_pw_multi_aff *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_union_pw_multi_aff_foreach_pw_multi_aff(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::from_aff(isl::aff aff)
 {
   auto res = isl_union_pw_multi_aff_from_aff(aff.release());
   return manage(res);
 }
 

 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::intersect_params(isl::set set) const
 {
   auto res = isl_union_pw_multi_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean union_pw_multi_aff::involves_nan() const
+bool union_pw_multi_aff::involves_nan(isl::quota &quota) const
 {
   auto res = isl_union_pw_multi_aff_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::multi_val_on_domain(isl::union_set domain, isl::multi_val mv)
 {
   auto res = isl_union_pw_multi_aff_multi_val_on_domain(domain.release(), mv.release());
   return manage(res);
 }
 
 int union_pw_multi_aff::n_pw_multi_aff() const
 {
   auto res = isl_union_pw_multi_aff_n_pw_multi_aff(get());
   return res;
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::neg() const
 {
   auto res = isl_union_pw_multi_aff_neg(copy());
   return manage(res);
 }
 
-isl::boolean union_pw_multi_aff::plain_is_equal(const isl::union_pw_multi_aff &upma2) const
+bool union_pw_multi_aff::plain_is_equal(const isl::union_pw_multi_aff &upma2, isl::quota &quota) const
 {
   auto res = isl_union_pw_multi_aff_plain_is_equal(get(), upma2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::pullback(isl::union_pw_multi_aff upma2) const
 {
   auto res = isl_union_pw_multi_aff_pullback_union_pw_multi_aff(copy(), upma2.release());
   return manage(res);
 }
 

 }
 
 int union_pw_qpolynomial::find_dim_by_name(isl::dim type, const std::string &name) const
 {
   auto res = isl_union_pw_qpolynomial_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
   return res;
 }
 
-isl::stat union_pw_qpolynomial::foreach_pw_qpolynomial(const std::function<isl::stat(isl::pw_qpolynomial)> &fn) const
+void union_pw_qpolynomial::foreach_pw_qpolynomial(const std::function<void(isl::pw_qpolynomial)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::pw_qpolynomial)> *func;
+    const std::function<void(isl::pw_qpolynomial)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_pw_qpolynomial *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_union_pw_qpolynomial_foreach_pw_qpolynomial(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::union_pw_qpolynomial union_pw_qpolynomial::from_pw_qpolynomial(isl::pw_qpolynomial pwqp)
 {
   auto res = isl_union_pw_qpolynomial_from_pw_qpolynomial(pwqp.release());
   return manage(res);
 }
 

 }
 
 isl::union_pw_qpolynomial union_pw_qpolynomial::intersect_params(isl::set set) const
 {
   auto res = isl_union_pw_qpolynomial_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean union_pw_qpolynomial::involves_nan() const
+bool union_pw_qpolynomial::involves_nan(isl::quota &quota) const
 {
   auto res = isl_union_pw_qpolynomial_involves_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_pw_qpolynomial union_pw_qpolynomial::mul(isl::union_pw_qpolynomial upwqp2) const
 {
   auto res = isl_union_pw_qpolynomial_mul(copy(), upwqp2.release());
   return manage(res);
 }
 
 int union_pw_qpolynomial::n_pw_qpolynomial() const
 {
   auto res = isl_union_pw_qpolynomial_n_pw_qpolynomial(get());
   return res;
 }
 
 isl::union_pw_qpolynomial union_pw_qpolynomial::neg() const
 {
   auto res = isl_union_pw_qpolynomial_neg(copy());
   return manage(res);
 }
 
-isl::boolean union_pw_qpolynomial::plain_is_equal(const isl::union_pw_qpolynomial &upwqp2) const
+bool union_pw_qpolynomial::plain_is_equal(const isl::union_pw_qpolynomial &upwqp2, isl::quota &quota) const
 {
   auto res = isl_union_pw_qpolynomial_plain_is_equal(get(), upwqp2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_pw_qpolynomial union_pw_qpolynomial::reset_user() const
 {
   auto res = isl_union_pw_qpolynomial_reset_user(copy());
   return manage(res);
 }
 

 }
 
 isl::schedule union_set::compute_schedule(isl::union_map validity, isl::union_map proximity) const
 {
   auto res = isl_union_set_compute_schedule(copy(), validity.release(), proximity.release());
   return manage(res);
 }
 
-isl::boolean union_set::contains(const isl::space &space) const
+bool union_set::contains(const isl::space &space, isl::quota &quota) const
 {
   auto res = isl_union_set_contains(get(), space.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_set union_set::detect_equalities() const
 {
   auto res = isl_union_set_detect_equalities(copy());
   return manage(res);
 }
 

 }
 
 isl::set union_set::extract_set(isl::space dim) const
 {
   auto res = isl_union_set_extract_set(get(), dim.release());
   return manage(res);
 }
 
-isl::stat union_set::foreach_point(const std::function<isl::stat(isl::point)> &fn) const
+void union_set::foreach_point(const std::function<void(isl::point)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::point)> *func;
+    const std::function<void(isl::point)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_point *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_union_set_foreach_point(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
-isl::stat union_set::foreach_set(const std::function<isl::stat(isl::set)> &fn) const
+void union_set::foreach_set(const std::function<void(isl::set)> &fn) const
 {
   struct fn_data {
-    const std::function<isl::stat(isl::set)> *func;
+    const std::function<void(isl::set)> *func;
   } fn_data = { &fn };
   auto fn_lambda = [](isl_set *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(isl::manage(arg_0));
-    return isl_stat(ret);
+    (*data->func)(isl::manage(arg_0));
+    return isl_stat_ok;
   };
   auto res = isl_union_set_foreach_set(get(), fn_lambda, &fn_data);
-  return isl::stat(res);
+  return void(res);
 }
 
 isl::basic_set_list union_set::get_basic_set_list() const
 {
   auto res = isl_union_set_get_basic_set_list(get());
   return manage(res);
 }
 

 }
 
 isl::union_set union_set::intersect_params(isl::set set) const
 {
   auto res = isl_union_set_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::boolean union_set::is_disjoint(const isl::union_set &uset2) const
+bool union_set::is_disjoint(const isl::union_set &uset2, isl::quota &quota) const
 {
   auto res = isl_union_set_is_disjoint(get(), uset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_set::is_empty() const
+bool union_set::is_empty(isl::quota &quota) const
 {
   auto res = isl_union_set_is_empty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_set::is_equal(const isl::union_set &uset2) const
+bool union_set::is_equal(const isl::union_set &uset2, isl::quota &quota) const
 {
   auto res = isl_union_set_is_equal(get(), uset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_set::is_params() const
+bool union_set::is_params(isl::quota &quota) const
 {
   auto res = isl_union_set_is_params(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_set::is_strict_subset(const isl::union_set &uset2) const
+bool union_set::is_strict_subset(const isl::union_set &uset2, isl::quota &quota) const
 {
   auto res = isl_union_set_is_strict_subset(get(), uset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean union_set::is_subset(const isl::union_set &uset2) const
+bool union_set::is_subset(const isl::union_set &uset2, isl::quota &quota) const
 {
   auto res = isl_union_set_is_subset(get(), uset2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::union_map union_set::lex_ge_union_set(isl::union_set uset2) const
 {
   auto res = isl_union_set_lex_ge_union_set(copy(), uset2.release());
   return manage(res);
 }
 

 }
 
 isl::val val::abs() const
 {
   auto res = isl_val_abs(copy());
   return manage(res);
 }
 
-isl::boolean val::abs_eq(const isl::val &v2) const
+bool val::abs_eq(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_abs_eq(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::val val::add(isl::val v2) const
 {
   auto res = isl_val_add(copy(), v2.release());
   return manage(res);
 }
 

 }
 
 isl::val val::div_ui(unsigned long v2) const
 {
   auto res = isl_val_div_ui(copy(), v2);
   return manage(res);
 }
 
-isl::boolean val::eq(const isl::val &v2) const
+bool val::eq(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_eq(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::val val::floor() const
 {
   auto res = isl_val_floor(copy());
   return manage(res);
 }
 
 isl::val val::gcd(isl::val v2) const
 {
   auto res = isl_val_gcd(copy(), v2.release());
   return manage(res);
 }
 
-isl::boolean val::ge(const isl::val &v2) const
+bool val::ge(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_ge(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 uint32_t val::get_hash() const
 {
   auto res = isl_val_get_hash(get());
   return res;
 }
 
 long val::get_num_si() const
 {
   auto res = isl_val_get_num_si(get());
   return res;
 }
 
-isl::boolean val::gt(const isl::val &v2) const
+bool val::gt(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_gt(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::gt_si(long i) const
+bool val::gt_si(long i, isl::quota &quota) const
 {
   auto res = isl_val_gt_si(get(), i);
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::val val::infty(isl::ctx ctx)
 {
   auto res = isl_val_infty(ctx.release());
   return manage(res);
 }
 
 isl::val val::int_from_ui(isl::ctx ctx, unsigned long u)
 {
   auto res = isl_val_int_from_ui(ctx.release(), u);
   return manage(res);
 }
 
 isl::val val::inv() const
 {
   auto res = isl_val_inv(copy());
   return manage(res);
 }
 
-isl::boolean val::is_divisible_by(const isl::val &v2) const
+bool val::is_divisible_by(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_is_divisible_by(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_infty() const
+bool val::is_infty(isl::quota &quota) const
 {
   auto res = isl_val_is_infty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_int() const
+bool val::is_int(isl::quota &quota) const
 {
   auto res = isl_val_is_int(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_nan() const
+bool val::is_nan(isl::quota &quota) const
 {
   auto res = isl_val_is_nan(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_neg() const
+bool val::is_neg(isl::quota &quota) const
 {
   auto res = isl_val_is_neg(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_neginfty() const
+bool val::is_neginfty(isl::quota &quota) const
 {
   auto res = isl_val_is_neginfty(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_negone() const
+bool val::is_negone(isl::quota &quota) const
 {
   auto res = isl_val_is_negone(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_nonneg() const
+bool val::is_nonneg(isl::quota &quota) const
 {
   auto res = isl_val_is_nonneg(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_nonpos() const
+bool val::is_nonpos(isl::quota &quota) const
 {
   auto res = isl_val_is_nonpos(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_one() const
+bool val::is_one(isl::quota &quota) const
 {
   auto res = isl_val_is_one(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_pos() const
+bool val::is_pos(isl::quota &quota) const
 {
   auto res = isl_val_is_pos(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_rat() const
+bool val::is_rat(isl::quota &quota) const
 {
   auto res = isl_val_is_rat(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::is_zero() const
+bool val::is_zero(isl::quota &quota) const
 {
   auto res = isl_val_is_zero(get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::le(const isl::val &v2) const
+bool val::le(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_le(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
-isl::boolean val::lt(const isl::val &v2) const
+bool val::lt(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_lt(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::val val::max(isl::val v2) const
 {
   auto res = isl_val_max(copy(), v2.release());
   return manage(res);
 }
 

 }
 
 isl::val val::nan(isl::ctx ctx)
 {
   auto res = isl_val_nan(ctx.release());
   return manage(res);
 }
 
-isl::boolean val::ne(const isl::val &v2) const
+bool val::ne(const isl::val &v2, isl::quota &quota) const
 {
   auto res = isl_val_ne(get(), v2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::val val::neg() const
 {
   auto res = isl_val_neg(copy());
   return manage(res);
 }
 

 }
 
 isl::vec vec::insert_zero_els(unsigned int pos, unsigned int n) const
 {
   auto res = isl_vec_insert_zero_els(copy(), pos, n);
   return manage(res);
 }
 
-isl::boolean vec::is_equal(const isl::vec &vec2) const
+bool vec::is_equal(const isl::vec &vec2, isl::quota &quota) const
 {
   auto res = isl_vec_is_equal(get(), vec2.get());
-  return manage(res);
+  if (res == isl_bool_error)
+    return quota.report_bool();
+  else
+    return res == isl_bool_true;
+  return res;
 }
 
 isl::vec vec::mat_product(isl::mat mat) const
 {
   auto res = isl_vec_mat_product(copy(), mat.release());
   return manage(res);
 }
 

lib/External/isl/isl_ctx.c

void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
 
   isl_ctx_set_full_error(ctx, error, msg, file, line);
 
   switch (ctx->opt->on_error) {
   case ISL_ON_ERROR_WARN:
     fprintf(stderr, "%s:%d: %s\n", file, line, msg);
     return;
   case ISL_ON_ERROR_CONTINUE:
+    fprintf(stderr, "%s:%d: %s\n", file, line, msg);
     return;
   case ISL_ON_ERROR_ABORT:
     fprintf(stderr, "%s:%d: %s\n", file, line, msg);
     abort();
     return;
   }
 }
 

lib/Support/ISLTools.cpp

 /// Construct a map that swaps two nested tuples.
 ///
 /// @param FromSpace1 { Space1[] }
 /// @param FromSpace2 { Space2[] }
 ///
 /// @return { [Space1[] -> Space2[]] -> [Space2[] -> Space1[]] }
 isl::basic_map makeTupleSwapBasicMap(isl::space FromSpace1,
                                      isl::space FromSpace2) {
-  assert(FromSpace1.is_set());
-  assert(FromSpace2.is_set());
+  assert(FromSpace1.is_set(isl::quota::ret_true));
+  assert(FromSpace2.is_set(isl::quota::ret_true));
 
   unsigned Dims1 = FromSpace1.dim(isl::dim::set);
   unsigned Dims2 = FromSpace2.dim(isl::dim::set);
 
   isl::space FromSpace =
       FromSpace1.map_from_domain_and_range(FromSpace2).wrap();
   isl::space ToSpace = FromSpace2.map_from_domain_and_range(FromSpace1).wrap();
   isl::space MapSpace = FromSpace.map_from_domain_and_range(ToSpace);
isl::map polly::beforeScatter(isl::map Map, bool Strict) {
   isl::space RangeSpace = Map.get_space().range();
   isl::map ScatterRel =
       Strict ? isl::map::lex_gt(RangeSpace) : isl::map::lex_ge(RangeSpace);
   return Map.apply_range(ScatterRel);
 }
 
 isl::union_map polly::beforeScatter(isl::union_map UMap, bool Strict) {
   isl::union_map Result = isl::union_map::empty(UMap.get_space());
-  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &Result](isl::map Map) {
     isl::map After = beforeScatter(Map, Strict);
     Result = Result.add_map(After);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::afterScatter(isl::map Map, bool Strict) {
   isl::space RangeSpace = Map.get_space().range();
   isl::map ScatterRel =
       Strict ? isl::map::lex_lt(RangeSpace) : isl::map::lex_le(RangeSpace);
   return Map.apply_range(ScatterRel);
 }
 
 isl::union_map polly::afterScatter(const isl::union_map &UMap, bool Strict) {
   isl::union_map Result = isl::union_map::empty(UMap.get_space());
-  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &Result](isl::map Map) {
     isl::map After = afterScatter(Map, Strict);
     Result = Result.add_map(After);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
                                bool InclTo) {
   isl::map AfterFrom = afterScatter(From, !InclFrom);
   isl::map BeforeTo = beforeScatter(To, !InclTo);

 isl::map polly::singleton(isl::union_map UMap, isl::space ExpectedSpace) {
   if (!UMap)
     return nullptr;
 
   if (isl_union_map_n_map(UMap.get()) == 0)
     return isl::map::empty(ExpectedSpace);
 
   isl::map Result = isl::map::from_union_map(UMap);
-  assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace));
+  assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace,
+                                                        isl::quota::ret_true));
 
   return Result;
 }
 
 isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
   if (!USet)
     return nullptr;
 
   if (isl_union_set_n_set(USet.get()) == 0)
     return isl::set::empty(ExpectedSpace);
 
   isl::set Result(USet);
-  assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace));
+  assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace,
+                                                        isl::quota::ret_true));
 
   return Result;
 }
 
 unsigned polly::getNumScatterDims(const isl::union_map &Schedule) {
   unsigned Dims = 0;
-  Schedule.foreach_map([&Dims](isl::map Map) -> isl::stat {
-    Dims = std::max(Dims, Map.dim(isl::dim::out));
-    return isl::stat::ok;
-  });
+  Schedule.foreach_map(
+      [&Dims](isl::map Map) { Dims = std::max(Dims, Map.dim(isl::dim::out)); });
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
   if (!Schedule)
     return nullptr;
   unsigned Dims = getNumScatterDims(Schedule);
   isl::space ScatterSpace = Schedule.get_space().set_from_params();
   return ScatterSpace.add_dims(isl::dim::set, Dims);
 }
 
 isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
                                       bool RestrictDomain) {
   isl::union_map Result = isl::union_map::empty(USet.get_space());
-  USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
+  USet.foreach_set([=, &Result](isl::set Set) {
     isl::map IdentityMap = isl::map::identity(Set.get_space().map_from_set());
     if (RestrictDomain)
       IdentityMap = IdentityMap.intersect_domain(Set);
     Result = Result.add_map(IdentityMap);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::reverseDomain(isl::map Map) {
   isl::space DomSpace = Map.get_space().domain().unwrap();
   isl::space Space1 = DomSpace.domain();
   isl::space Space2 = DomSpace.range();
   isl::map Swap = makeTupleSwapMap(Space1, Space2);
   return Map.apply_domain(Swap);
 }
 
 isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
   isl::union_map Result = isl::union_map::empty(UMap.get_space());
-  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &Result](isl::map Map) {
     auto Reversed = reverseDomain(std::move(Map));
     Result = Result.add_map(Reversed);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
   int NumDims = Set.dim(isl::dim::set);
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   isl::space Space = Set.get_space();
   Space = Space.map_from_domain_and_range(Space);
   isl::multi_aff Translator = makeShiftDimAff(Space, Pos, Amount);
   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
   return Set.apply(TranslatorMap);
 }
 
 isl::union_set polly::shiftDim(isl::union_set USet, int Pos, int Amount) {
   isl::union_set Result = isl::union_set::empty(USet.get_space());
-  USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
+  USet.foreach_set([=, &Result](isl::set Set) {
     isl::set Shifted = shiftDim(Set, Pos, Amount);
     Result = Result.add_set(Shifted);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
   int NumDims = Map.dim(Dim);
   if (Pos < 0)
     Pos = NumDims + Pos;
default:
     llvm_unreachable("Unsupported value for 'dim'");
   }
 }
 
 isl::union_map polly::shiftDim(isl::union_map UMap, isl::dim Dim, int Pos,
                                int Amount) {
   isl::union_map Result = isl::union_map::empty(UMap.get_space());
 
-  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &Result](isl::map Map) {
     isl::map Shifted = shiftDim(Map, Dim, Pos, Amount);
     Result = Result.add_map(Shifted);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 void polly::simplify(isl::set &Set) {
   Set = isl::manage(isl_set_compute_divs(Set.copy()));
   Set = Set.detect_equalities();
   Set = Set.coalesce();
isl::map polly::distributeDomain(isl::map Map) {
   return Map.wrap().apply(Translator).unwrap();
 }
 
 isl::union_map polly::distributeDomain(isl::union_map UMap) {
   isl::union_map Result = isl::union_map::empty(UMap.get_space());
   UMap.foreach_map([=, &Result](isl::map Map) {
     auto Distributed = distributeDomain(Map);
     Result = Result.add_map(Distributed);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::union_map polly::liftDomains(isl::union_map UMap, isl::union_set Factor) {
 
   // { Factor[] -> Factor[] }
   isl::union_map Factors = makeIdentityMap(Factor, true);

 isl::map polly::intersectRange(isl::map Map, isl::union_set Range) {
   isl::set RangeSet = Range.extract_set(Map.get_space().range());
   return Map.intersect_range(RangeSet);
 }
 
 isl::val polly::getConstant(isl::pw_aff PwAff, bool Max, bool Min) {
   assert(!Max || !Min); // Cannot return min and max at the same time.
   isl::val Result;
-  PwAff.foreach_piece([=, &Result](isl::set Set, isl::aff Aff) -> isl::stat {
-    if (Result && Result.is_nan())
-      return isl::stat::ok;
+  PwAff.foreach_piece([=, &Result](isl::set Set, isl::aff Aff) {
+    if (Result && Result.is_nan(isl::quota::unclear))
+      return;
 
     // TODO: If Min/Max, we can also determine a minimum/maximum value if
     // Set is constant-bounded.
-    if (!Aff.is_cst()) {
+    if (!Aff.is_cst(isl::quota::unclear)) {
       Result = isl::val::nan(Aff.get_ctx());
-      return isl::stat::ok;
+      return;
     }
 
     isl::val ThisVal = Aff.get_constant_val();
     if (!Result) {
       Result = ThisVal;
-      return isl::stat::ok;
+      return;
     }
 
-    if (Result.eq(ThisVal))
-      return isl::stat::ok;
+    if (Result.eq(ThisVal, isl::quota::unclear))
+      return;
 
-    if (Max && ThisVal.gt(Result)) {
+    if (Max && ThisVal.gt(Result, isl::quota::unclear)) {
       Result = ThisVal;
-      return isl::stat::ok;
+      return;
     }
 
-    if (Min && ThisVal.lt(Result)) {
+    if (Min && ThisVal.lt(Result, isl::quota::unclear)) {
       Result = ThisVal;
-      return isl::stat::ok;
+      return;
     }
 
     // Not compatible
     Result = isl::val::nan(Aff.get_ctx());
-    return isl::stat::ok;
+    return;
   });
   return Result;
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 static void foreachPoint(const isl::set &Set,
                          const std::function<void(isl::point P)> &F) {
-  Set.foreach_point([&](isl::point P) -> isl::stat {
-    F(P);
-    return isl::stat::ok;
-  });
+  Set.foreach_point([&](isl::point P) { F(P); });
 }
 
 static void foreachPoint(isl::basic_set BSet,
                          const std::function<void(isl::point P)> &F) {
   foreachPoint(isl::set(BSet), F);
 }
 
 /// Determine the sorting order of the sets @p A and @p B without considering
for (unsigned i = 0; i < Len; i += 1) {
     isl::basic_set BDim =
         B.project_out(isl::dim::param, 0, B.dim(isl::dim::param))
             .project_out(isl::dim::set, i + 1, BLen - i - 1)
             .project_out(isl::dim::set, 0, i);
 
     isl::basic_set AHull = isl::set(ADim).convex_hull();
     isl::basic_set BHull = isl::set(BDim).convex_hull();
 
-    bool ALowerBounded =
-        bool(isl::set(AHull).dim_has_any_lower_bound(isl::dim::set, 0));
-    bool BLowerBounded =
-        bool(isl::set(BHull).dim_has_any_lower_bound(isl::dim::set, 0));
+    bool ALowerBounded = bool(isl::set(AHull).dim_has_any_lower_bound(
+        isl::dim::set, 0, isl::quota::unclear));
+    bool BLowerBounded = bool(isl::set(BHull).dim_has_any_lower_bound(
+        isl::dim::set, 0, isl::quota::unclear));
 
     int BoundedCompare = BLowerBounded - ALowerBounded;
     if (BoundedCompare != 0)
       return BoundedCompare;
 
     if (!ALowerBounded || !BLowerBounded)
       continue;
 

 
 /// Compare the sets @p A and @p B according to their nested space structure.
 /// Returns 0 if the structure is considered equal.
 /// If @p ConsiderTupleLen is false, the number of dimensions in a tuple are
 /// ignored, i.e. a tuple with the same name but different number of dimensions
 /// are considered equal.
 static int structureCompare(const isl::space &ASpace, const isl::space &BSpace,
                             bool ConsiderTupleLen) {
-  int WrappingCompare = bool(ASpace.is_wrapping()) - bool(BSpace.is_wrapping());
+  int WrappingCompare = bool(ASpace.is_wrapping(isl::quota::unclear)) -
+                        bool(BSpace.is_wrapping(isl::quota::unclear));
   if (WrappingCompare != 0)
     return WrappingCompare;
 
-  if (ASpace.is_wrapping() && BSpace.is_wrapping()) {
+  if (ASpace.is_wrapping(isl::quota::unclear) &&
+      BSpace.is_wrapping(isl::quota::unclear)) {
     isl::space AMap = ASpace.unwrap();
     isl::space BMap = BSpace.unwrap();
 
     int FirstResult =
         structureCompare(AMap.domain(), BMap.domain(), ConsiderTupleLen);
     if (FirstResult != 0)
       return FirstResult;
 
     return structureCompare(AMap.range(), BMap.range(), ConsiderTupleLen);
   }
 
   std::string AName;
-  if (ASpace.has_tuple_name(isl::dim::set))
+  if (ASpace.has_tuple_name(isl::dim::set, isl::quota::unclear))
     AName = ASpace.get_tuple_name(isl::dim::set);
 
   std::string BName;
-  if (BSpace.has_tuple_name(isl::dim::set))
+  if (BSpace.has_tuple_name(isl::dim::set, isl::quota::unclear))
     BName = BSpace.get_tuple_name(isl::dim::set);
 
   int NameCompare = AName.compare(BName);
   if (NameCompare != 0)
     return NameCompare;
 
   if (ConsiderTupleLen) {
     int LenCompare = BSpace.dim(isl::dim::set) - ASpace.dim(isl::dim::set);
if (!USet) {
     return;
   }
 
   if (Simplify)
     simplify(USet);
 
   // Get all the polyhedra.
   std::vector<isl::basic_set> BSets;
-  USet.foreach_set([&BSets](isl::set Set) -> isl::stat {
-    Set.foreach_basic_set([&BSets](isl::basic_set BSet) -> isl::stat {
+  USet.foreach_set([&BSets](isl::set Set) {
+    Set.foreach_basic_set([&BSets](isl::basic_set BSet) {
       BSets.push_back(BSet);
-      return isl::stat::ok;
+      return;
     });
-    return isl::stat::ok;
+    return;
   });
 
   if (BSets.empty()) {
     OS << "{\n}\n";
     return;
   }
 
   // Sort the polyhedra.
if (Dim >= Dims) {
     Expanded = Expanded.unite(BSet);
     return;
   }
 
   isl::basic_set DimOnly =
       BSet.project_out(isl::dim::param, 0, BSet.dim(isl::dim::param))
           .project_out(isl::dim::set, Dim + 1, Dims - Dim - 1)
           .project_out(isl::dim::set, 0, Dim);
-  if (!DimOnly.is_bounded()) {
+  if (!DimOnly.is_bounded(isl::quota::unclear)) {
     recursiveExpand(BSet, Dim + 1, Expanded);
     return;
   }
 
   foreachPoint(DimOnly, [&, Dim](isl::point P) {
     isl::val Val = P.get_coordinate_val(isl::dim::set, 0);
     isl::basic_set FixBSet = BSet.fix_val(isl::dim::set, Dim, Val);
     recursiveExpand(FixBSet, Dim + 1, Expanded);
   });
 }
 
 /// Make each point of a set explicit.
 ///
 /// "Expanding" makes each point a set contains explicit. That is, the result is
 /// a set of singleton polyhedra. Unbounded dimensions are not expanded.
 ///
 /// Example:
 ///   { [i] : 0 <= i < 2 }
 /// is expanded to:
 ///   { [0]; [1] }
 static isl::set expand(const isl::set &Set) {
   isl::set Expanded = isl::set::empty(Set.get_space());
-  Set.foreach_basic_set([&](isl::basic_set BSet) -> isl::stat {
+  Set.foreach_basic_set([&](isl::basic_set BSet) {
     recursiveExpand(BSet, 0, Expanded);
-    return isl::stat::ok;
+    return;
   });
   return Expanded;
 }
 
 /// Expand all points of a union set explicit.
 ///
 /// @see expand(const isl::set)
 static isl::union_set expand(const isl::union_set &USet) {
   isl::union_set Expanded = isl::union_set::empty(USet.get_space());
-  USet.foreach_set([&](isl::set Set) -> isl::stat {
+  USet.foreach_set([&](isl::set Set) {
     isl::set SetExpanded = expand(Set);
     Expanded = Expanded.add_set(SetExpanded);
-    return isl::stat::ok;
   });
   return Expanded;
 }
 
 LLVM_DUMP_METHOD void polly::dumpPw(const isl::set &Set) {
   printSortedPolyhedra(Set, llvm::errs(), true, false);
 }
 

lib/Support/SCEVAffinator.cpp

PWACtx SCEVAffinator::checkForWrapping(const SCEV *Expr, PWACtx PWAC) const {
   isl::set NotEqualSet = PWAC.first.ne_set(PWAMod);
   PWAC.second = PWAC.second.unite(NotEqualSet).coalesce();
 
   const DebugLoc &Loc = BB ? BB->getTerminator()->getDebugLoc() : DebugLoc();
   if (!BB)
     NotEqualSet = NotEqualSet.params();
   NotEqualSet = NotEqualSet.coalesce();
 
-  if (!NotEqualSet.is_empty())
+  if (!NotEqualSet.is_empty(isl::quota::unclear))
     S->recordAssumption(WRAPPING, NotEqualSet, Loc, AS_RESTRICTION, BB);
 
   return PWAC;
 }
 
 isl::pw_aff SCEVAffinator::addModuloSemantic(isl::pw_aff PWA,
                                              Type *ExprType) const {
   unsigned Width = TD.getTypeSizeInBits(ExprType);

lib/Transform/DeLICM.cpp

#ifndef NDEBUG
     assert(Occupied || Unused);
     assert(Known);
     assert(Written);
 
     // If not all fields are defined, we cannot derived the universe.
     if (!Occupied || !Unused)
       return;
 
-    assert(Occupied.is_disjoint(Unused));
+    assert(Occupied.is_disjoint(Unused, isl::quota::ret_true));
     auto Universe = Occupied.unite(Unused);
 
-    assert(!Known.domain().is_subset(Universe).is_false());
-    assert(!Written.domain().is_subset(Universe).is_false());
+    assert(Known.domain().is_subset(Universe, isl::quota::ret_true));
+    assert(Written.domain().is_subset(Universe, isl::quota::ret_true));
 #endif
   }
 
 public:
   /// Initialize a nullptr-Knowledge. This is only provided for convenience; do
   /// not use such an object.
   Knowledge() {}
 
static bool isConflicting(const Knowledge &Existing,
                             unsigned Indent = 0) {
     assert(Existing.Unused);
     assert(Proposed.Occupied);
 
 #ifndef NDEBUG
     if (Existing.Occupied && Proposed.Unused) {
       auto ExistingUniverse = Existing.Occupied.unite(Existing.Unused);
       auto ProposedUniverse = Proposed.Occupied.unite(Proposed.Unused);
-      assert(ExistingUniverse.is_equal(ProposedUniverse) &&
-             "Both inputs' Knowledges must be over the same universe");
+      assert(
+          ExistingUniverse.is_equal(ProposedUniverse, isl::quota::ret_true) &&
     }
 #endif
 
     // Do the Existing and Proposed lifetimes conflict?
     //
     // Lifetimes are described as the cross-product of array elements and zone
     // intervals in which they are alive (the space { [Element[] -> Zone[]] }).
     // In the following we call this "element/lifetime interval".
#endif
     auto ExistingValues = Existing.Known.unite(ExistingUnusedAnyVal);
 
     auto MatchingVals = ExistingValues.intersect(ProposedValues);
     auto Matches = MatchingVals.domain();
 
     // Any Proposed.Occupied must either have a match between the known values
     // of Existing and Occupied, or be in Existing.Unused. In the latter case,
     // the previously added "AnyVal" will match each other.
-    if (!Proposed.Occupied.is_subset(Matches)) {
+    if (!Proposed.Occupied.is_subset(Matches, isl::quota::unclear)) {
       if (OS) {
         auto Conflicting = Proposed.Occupied.subtract(Matches);
         auto ExistingConflictingKnown =
             Existing.Known.intersect_domain(Conflicting);
         auto ProposedConflictingKnown =
             Proposed.Known.intersect_domain(Conflicting);
 
         OS->indent(Indent) << "Proposed lifetime conflicting with Existing's\n";
         OS->indent(Indent) << "Conflicting occupied: " << Conflicting << "\n";
-        if (!ExistingConflictingKnown.is_empty())
+        if (!ExistingConflictingKnown.is_empty(isl::quota::unclear))
           OS->indent(Indent)
               << "Existing Known:       " << ExistingConflictingKnown << "\n";
-        if (!ProposedConflictingKnown.is_empty())
+        if (!ProposedConflictingKnown.is_empty(isl::quota::unclear))
           OS->indent(Indent)
               << "Proposed Known:       " << ProposedConflictingKnown << "\n";
       }
       return true;
     }
 
     // Do the writes in Existing conflict with occupied values in Proposed?
     //
#endif
     auto ExistingConflictingWrites =
         Existing.Written.intersect_domain(ProposedFixedDefs);
     auto ExistingConflictingWritesDomain = ExistingConflictingWrites.domain();
 
     auto CommonWrittenVal =
         ProposedFixedKnown.intersect(ExistingConflictingWrites);
     auto CommonWrittenValDomain = CommonWrittenVal.domain();
 
-    if (!ExistingConflictingWritesDomain.is_subset(CommonWrittenValDomain)) {
+    if (!ExistingConflictingWritesDomain.is_subset(CommonWrittenValDomain,
+                                                   isl::quota::unclear)) {
       if (OS) {
         auto ExistingConflictingWritten =
             ExistingConflictingWrites.subtract_domain(CommonWrittenValDomain);
         auto ProposedConflictingKnown = ProposedFixedKnown.subtract_domain(
             ExistingConflictingWritten.domain());
 
         OS->indent(Indent)
             << "Proposed a lifetime where there is an Existing write into it\n";
         OS->indent(Indent) << "Existing conflicting writes: "
                            << ExistingConflictingWritten << "\n";
-        if (!ProposedConflictingKnown.is_empty())
+        if (!ProposedConflictingKnown.is_empty(isl::quota::unclear))
           OS->indent(Indent)
               << "Proposed conflicting known:  " << ProposedConflictingKnown
               << "\n";
       }
       return true;
     }
 
     // Do the writes in Proposed conflict with occupied values in Existing?
     auto ExistingAvailableDefs =
         convertZoneToTimepoints(Existing.Unused, true, false);
     auto ExistingKnownDefs =
         convertZoneToTimepoints(Existing.Known, isl::dim::in, true, false);
 
     auto ProposedWrittenDomain = Proposed.Written.domain();
     auto KnownIdentical = ExistingKnownDefs.intersect(Proposed.Written);
     auto IdenticalOrUnused =
         ExistingAvailableDefs.unite(KnownIdentical.domain());
-    if (!ProposedWrittenDomain.is_subset(IdenticalOrUnused)) {
+    if (!ProposedWrittenDomain.is_subset(IdenticalOrUnused,
+                                         isl::quota::unclear)) {
       if (OS) {
         auto Conflicting = ProposedWrittenDomain.subtract(IdenticalOrUnused);
         auto ExistingConflictingKnown =
             ExistingKnownDefs.intersect_domain(Conflicting);
         auto ProposedConflictingWritten =
             Proposed.Written.intersect_domain(Conflicting);
 
         OS->indent(Indent) << "Proposed writes into range used by Existing\n";
         OS->indent(Indent) << "Proposed conflicting writes: "
                            << ProposedConflictingWritten << "\n";
-        if (!ExistingConflictingKnown.is_empty())
+        if (!ExistingConflictingKnown.is_empty(isl::quota::unclear))
           OS->indent(Indent)
               << "Existing conflicting known: " << ExistingConflictingKnown
               << "\n";
       }
       return true;
     }
 
     // Does Proposed write at the same time as Existing already does (order of
     // writes is undefined)? Writing the same value is permitted.
     auto ExistingWrittenDomain = Existing.Written.domain();
     auto BothWritten =
         Existing.Written.domain().intersect(Proposed.Written.domain());
     auto ExistingKnownWritten = filterKnownValInst(Existing.Written);
     auto ProposedKnownWritten = filterKnownValInst(Proposed.Written);
     auto CommonWritten =
         ExistingKnownWritten.intersect(ProposedKnownWritten).domain();
 
-    if (!BothWritten.is_subset(CommonWritten)) {
+    if (!BothWritten.is_subset(CommonWritten, isl::quota::unclear)) {
       if (OS) {
         auto Conflicting = BothWritten.subtract(CommonWritten);
         auto ExistingConflictingWritten =
             Existing.Written.intersect_domain(Conflicting);
         auto ProposedConflictingWritten =
             Proposed.Written.intersect_domain(Conflicting);
 
         OS->indent(Indent) << "Proposed writes at the same time as an already "
                               "Existing write\n";
         OS->indent(Indent) << "Conflicting writes: " << Conflicting << "\n";
-        if (!ExistingConflictingWritten.is_empty())
+        if (!ExistingConflictingWritten.is_empty(isl::quota::unclear))
           OS->indent(Indent)
               << "Exiting write:      " << ExistingConflictingWritten << "\n";
-        if (!ProposedConflictingWritten.is_empty())
+        if (!ProposedConflictingWritten.is_empty(isl::quota::unclear))
           OS->indent(Indent)
               << "Proposed write:     " << ProposedConflictingWritten << "\n";
       }
       return true;
     }
 
     return false;
   }
bool tryMapValue(const ScopArrayInfo *SAI, isl::map TargetElt) {
     // Where each write is mapped to, according to the suggestion.
     // { DomainDef[] -> Element[] }
     auto DefTarget = TargetElt.apply_domain(DefSched.reverse());
     simplify(DefTarget);
     DEBUG(dbgs() << "    Def Mapping: " << DefTarget << '\n');
 
     auto OrigDomain = getDomainFor(DefMA);
     auto MappedDomain = DefTarget.domain();
-    if (!OrigDomain.is_subset(MappedDomain)) {
+    if (!OrigDomain.is_subset(MappedDomain, isl::quota::unclear)) {
       DEBUG(dbgs()
             << "    Reject because mapping does not encompass all instances\n");
       return false;
     }
 
     // { DomainDef[] -> Zone[] }
     isl::map Lifetime;
 
for (auto *MA : S->getPHIIncomings(SAI)) {
         // We currently model it as unknown value, but modeling as the PHIInst
         // itself could be OK, too.
         ValInst = makeUnknownForDomain(WriteStmt);
       }
 
       Result = Result.unite(ValInst);
     }
 
-    assert(Result.is_single_valued() &&
+    assert(Result.is_single_valued(isl::quota::unclear) &&
            "Cannot have multiple incoming values for same incoming statement");
     return Result;
   }
 
   /// Try to map a MemoryKind::PHI scalar to a given array element.
   ///
   /// @param SAI       Representation of the scalar's memory to map.
   /// @param TargetElt { Scatter[] -> Element[] }
bool tryMapPHI(const ScopArrayInfo *SAI, isl::map TargetElt) {
 
     // { DomainRead[] -> Element[] }
     auto PHITarget = PHISched.apply_range(TargetElt);
     simplify(PHITarget);
     DEBUG(dbgs() << "    Mapping: " << PHITarget << '\n');
 
     auto OrigDomain = getDomainFor(PHIRead);
     auto MappedDomain = PHITarget.domain();
-    if (!OrigDomain.is_subset(MappedDomain)) {
+    if (!OrigDomain.is_subset(MappedDomain, isl::quota::unclear)) {
       DEBUG(dbgs()
             << "    Reject because mapping does not encompass all instances\n");
       return false;
     }
 
     // { DomainRead[] -> DomainWrite[] }
     auto PerPHIWrites = computePerPHI(SAI);
 
     // { DomainWrite[] -> Element[] }
     auto WritesTarget = PerPHIWrites.apply_domain(PHITarget).reverse();
     simplify(WritesTarget);
 
     // { DomainWrite[] }
     auto UniverseWritesDom = isl::union_set::empty(ParamSpace);
 
     for (auto *MA : S->getPHIIncomings(SAI))
       UniverseWritesDom = UniverseWritesDom.add_set(getDomainFor(MA));
 
     auto RelevantWritesTarget = WritesTarget;
     if (DelicmOverapproximateWrites)
       WritesTarget = expandMapping(WritesTarget, UniverseWritesDom);
 
     auto ExpandedWritesDom = WritesTarget.domain();
     if (!DelicmPartialWrites &&
-        !UniverseWritesDom.is_subset(ExpandedWritesDom)) {
+        !UniverseWritesDom.is_subset(ExpandedWritesDom, isl::quota::unclear)) {
       DEBUG(dbgs() << "    Reject because did not find PHI write mapping for "
                       "all instances\n");
       if (DelicmOverapproximateWrites)
         DEBUG(dbgs() << "      Relevant Mapping:    " << RelevantWritesTarget
                      << '\n');
       DEBUG(dbgs() << "      Deduced Mapping:     " << WritesTarget << '\n');
       DEBUG(dbgs() << "      Missing instances:    "
                    << UniverseWritesDom.subtract(ExpandedWritesDom) << '\n');
private:
   ///
   /// @param MA The access to test.
   ///
   /// @return True, if zero or one elements are accessed; False if at least two
   ///         different elements are accessed.
   bool isScalarAccess(MemoryAccess *MA) {
     auto Map = getAccessRelationFor(MA);
     auto Set = Map.range();
-    return Set.is_singleton();
+    return Set.is_singleton(isl::quota::unclear);
   }
 
   /// Print mapping statistics to @p OS.
   void printStatistics(llvm::raw_ostream &OS, int Indent = 0) const {
     OS.indent(Indent) << "Statistics {\n";
     OS.indent(Indent + 4) << "Compatible overwrites: "
                           << NumberOfCompatibleTargets << "\n";
     OS.indent(Indent + 4) << "Overwrites mapped to:  " << NumberOfTargetsMapped
for (auto &Stmt : *S) {
         //
         // This may occur when some accesses to the element write/read only
         // parts of the element, eg. a single byte. Polly then divides each
         // element into subelements of the smallest access length, normal access
         // then touch multiple of such subelements. It is very common when the
         // array is accesses with memset, memcpy or memmove which take i8*
         // arguments.
         isl::union_map AccRel = MA->getLatestAccessRelation();
-        if (!AccRel.is_single_valued().is_true()) {
+        if (!AccRel.is_single_valued(isl::quota::unclear)) {
           DEBUG(dbgs() << "Access " << MA
                        << " is incompatible because it writes multiple "
                           "elements per instance\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "NonFunctionalAccRel",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because it writes more than "
                "one element";
           S->getFunction().getContext().diagnose(R);
           continue;
         }
 
         isl::union_set TouchedElts = AccRel.range();
-        if (!TouchedElts.is_subset(CompatibleElts)) {
+        if (!TouchedElts.is_subset(CompatibleElts, isl::quota::unclear)) {
           DEBUG(
               dbgs()
               << "Access " << MA
               << " is incompatible because it touches incompatible elements\n");
           OptimizationRemarkMissed R(DEBUG_TYPE, "IncompatibleElts",
                                      MA->getAccessInstruction());
           R << "skipped possible mapping target because a target location "
                "cannot be reliably analyzed";

lib/Transform/DeadCodeElimination.cpp

bool DeadCodeElim::eliminateDeadCode(Scop &S, int PreciseSteps) {
 
   isl::union_set OriginalDomain = S.getDomains();
   int Steps = 0;
   while (true) {
     Steps++;
 
     isl::union_set Extra = Live.apply(Dep);
 
-    if (Extra.is_subset(Live))
+    if (Extra.is_subset(Live, isl::quota::unclear))
       break;
 
     Live = Live.unite(Extra);
 
     if (Steps > PreciseSteps) {
       Steps = 0;
       Live = Live.affine_hull();
     }

lib/Transform/FlattenAlgo.cpp

 /// i.e. there are two constants Min and Max, such that every value x of the
 /// chosen dimensions is Min <= x <= Max.
 bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
   auto ParamDims = Set.dim(isl::dim::param);
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
   auto SetDims = Set.dim(isl::dim::set);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
-  return bool(Set.is_bounded());
+  return bool(Set.is_bounded(isl::quota::unclear));
 }
 
 /// Whether a dimension of a set is (lower and upper) bounded by a constant or
 /// parameters, i.e. there are two expressions Min_p and Max_p of the parameters
 /// p, such that every value x of the chosen dimensions is
 /// Min_p <= x <= Max_p.
 bool isDimBoundedByParameter(isl::set Set, unsigned dim) {
   Set = Set.project_out(isl::dim::set, 0, dim);
   auto SetDims = Set.dim(isl::dim::set);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
-  return bool(Set.is_bounded());
+  return bool(Set.is_bounded(isl::quota::unclear));
 }
 
 /// Whether BMap's first out-dimension is not a constant.
 bool isVariableDim(const isl::basic_map &BMap) {
   auto FixedVal = BMap.plain_get_val_if_fixed(isl::dim::out, 0);
-  return !FixedVal || FixedVal.is_nan();
+  return !FixedVal || FixedVal.is_nan(isl::quota::unclear);
 }
 
 /// Whether Map's first out dimension is no constant nor piecewise constant.
 bool isVariableDim(const isl::map &Map) {
   bool IsVariableDim = false;
 
-  Map.foreach_basic_map([&](isl::basic_map BMap) -> isl::stat {
+  Map.foreach_basic_map([&](isl::basic_map BMap) {
     if (isVariableDim(BMap))
       IsVariableDim = true;
-    return isl::stat::ok;
+    return;
   });
 
   return IsVariableDim;
 }
 
 /// Whether UMap's first out dimension is no (piecewise) constant.
 bool isVariableDim(const isl::union_map &UMap) {
   bool IsVariableDim = false;
 
   UMap.foreach_map([&](isl::map Map) {
     if (isVariableDim(Map))
       IsVariableDim = true;
-    return isl::stat::ok;
+    return;
   });
 
   return IsVariableDim;
 }
 
 /// Compute @p UPwAff - @p Val.
 isl::union_pw_aff subtract(isl::union_pw_aff UPwAff, isl::val Val) {
-  if (Val.is_zero())
+  if (Val.is_zero(isl::quota::unclear))
     return UPwAff;
 
   auto Result = isl::union_pw_aff::empty(UPwAff.get_space());
-  UPwAff.foreach_pw_aff([=, &Result](isl::pw_aff PwAff) -> isl::stat {
+  UPwAff.foreach_pw_aff([=, &Result](isl::pw_aff PwAff) {
     auto ValAff =
         isl::pw_aff(isl::set::universe(PwAff.get_space().domain()), Val);
     auto Subtracted = PwAff.sub(ValAff);
     Result = Result.union_add(isl::union_pw_aff(Subtracted));
-    return isl::stat::ok;
+    return;
   });
   return Result;
 }
 
 /// Compute @UPwAff * @p Val.
 isl::union_pw_aff multiply(isl::union_pw_aff UPwAff, isl::val Val) {
-  if (Val.is_one())
+  if (Val.is_one(isl::quota::unclear))
     return UPwAff;
 
   auto Result = isl::union_pw_aff::empty(UPwAff.get_space());
-  UPwAff.foreach_pw_aff([=, &Result](isl::pw_aff PwAff) -> isl::stat {
+  UPwAff.foreach_pw_aff([=, &Result](isl::pw_aff PwAff) {
     auto ValAff =
         isl::pw_aff(isl::set::universe(PwAff.get_space().domain()), Val);
     auto Multiplied = PwAff.mul(ValAff);
     Result = Result.union_add(Multiplied);
-    return isl::stat::ok;
+    return;
   });
   return Result;
 }
 
 /// Remove @p n dimensions from @p UMap's range, starting at @p first.
 ///
 /// It is assumed that all maps in the maps have at least the necessary number
 /// of out dimensions.
 isl::union_map scheduleProjectOut(const isl::union_map &UMap, unsigned first,
                                   unsigned n) {
   if (n == 0)
     return UMap; /* isl_map_project_out would also reset the tuple, which should
                     have no effect on schedule ranges */
 
   auto Result = isl::union_map::empty(UMap.get_space());
-  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &Result](isl::map Map) {
     auto Outprojected = Map.project_out(isl::dim::out, first, n);
     Result = Result.add_map(Outprojected);
-    return isl::stat::ok;
+    return;
   });
   return Result;
 }
 
 /// Return the number of dimensions in the input map's range.
 ///
 /// Because this function takes an isl_union_map, the out dimensions could be
 /// different. We return the maximum number in this case. However, a different
 /// number of dimensions is not supported by the other code in this file.
 size_t scheduleScatterDims(const isl::union_map &Schedule) {
   unsigned Dims = 0;
-  Schedule.foreach_map([&Dims](isl::map Map) -> isl::stat {
+  Schedule.foreach_map([&Dims](isl::map Map) {
     Dims = std::max(Dims, Map.dim(isl::dim::out));
-    return isl::stat::ok;
+    return;
   });
   return Dims;
 }
 
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
 isl::union_pw_aff scheduleExtractDimAff(isl::union_map UMap, unsigned pos) {
   auto SingleUMap = isl::union_map::empty(UMap.get_space());
-  UMap.foreach_map([=, &SingleUMap](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &SingleUMap](isl::map Map) {
     auto MapDims = Map.dim(isl::dim::out);
     auto SingleMap = Map.project_out(isl::dim::out, 0, pos);
     SingleMap = SingleMap.project_out(isl::dim::out, 1, MapDims - pos - 1);
     SingleUMap = SingleUMap.add_map(SingleMap);
-    return isl::stat::ok;
+    return;
   });
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
   auto FirstMAff = isl::multi_union_pw_aff(UAff);
   return FirstMAff.get_union_pw_aff(0);
 }
 
 /// Flatten a sequence-like first dimension.
isl::union_map tryFlattenSequence(isl::union_map Schedule) {
   }
 
   auto AllDomains = Schedule.domain();
   auto AllDomainsToNull = isl::union_pw_multi_aff(AllDomains);
 
   auto NewSchedule = isl::union_map::empty(ParamSpace);
   auto Counter = isl::pw_aff(isl::local_space(ParamSpace.set_from_params()));
 
-  while (!ScatterSet.is_empty()) {
+  while (!ScatterSet.is_empty(isl::quota::unclear)) {
     DEBUG(dbgs() << "Next counter:\n  " << Counter << "\n");
     DEBUG(dbgs() << "Remaining scatter set:\n  " << ScatterSet << "\n");
     auto ThisSet = ScatterSet.project_out(isl::dim::set, 1, Dims - 1);
     auto ThisFirst = ThisSet.lexmin();
     auto ScatterFirst = ThisFirst.add_dims(isl::dim::set, Dims - 1);
 
     auto SubSchedule = Schedule.intersect_range(ScatterFirst);
     SubSchedule = scheduleProjectOut(SubSchedule, 0, 1);
isl::union_map tryFlattenLoop(isl::union_map Schedule) {
 
   auto Min = SubExtent.dim_min(0);
   DEBUG(dbgs() << "Min bound:\n  " << Min << "\n");
   auto MinVal = getConstant(Min, false, true);
   auto Max = SubExtent.dim_max(0);
   DEBUG(dbgs() << "Max bound:\n  " << Max << "\n");
   auto MaxVal = getConstant(Max, true, false);
 
-  if (!MinVal || !MaxVal || MinVal.is_nan() || MaxVal.is_nan()) {
+  if (!MinVal || !MaxVal || MinVal.is_nan(isl::quota::unclear) ||
+      MaxVal.is_nan(isl::quota::unclear)) {
     DEBUG(dbgs() << "Abort; dimension bounds could not be determined\n");
     return nullptr;
   }
 
   auto FirstSubScheduleAff = scheduleExtractDimAff(SubSchedule, 0);
   auto RemainingSubSchedule = scheduleProjectOut(std::move(SubSchedule), 0, 1);
 
   auto LenVal = MaxVal.sub(MinVal).add_ui(1);

lib/Transform/FlattenSchedule.cpp

 
 namespace {
 
 /// Print a schedule to @p OS.
 ///
 /// Prints the schedule for each statements on a new line.
 void printSchedule(raw_ostream &OS, const isl::union_map &Schedule,
                    int indent) {
-  Schedule.foreach_map([&OS, indent](isl::map Map) -> isl::stat {
+  Schedule.foreach_map([&OS, indent](isl::map Map) {
     OS.indent(indent) << Map << "\n";
-    return isl::stat::ok;
+    return;
   });
 }
 
 /// Flatten the schedule stored in an polly::Scop.
 class FlattenSchedule : public ScopPass {
 private:
   FlattenSchedule(const FlattenSchedule &) = delete;
   const FlattenSchedule &operator=(const FlattenSchedule &) = delete;

lib/Transform/ForwardOpTree.cpp

private:
   /// @param ValInst { Domain[] -> ValInst[] }
   ///                The values for which we search for alternative locations,
   ///                per statement instance.
   ///
   /// @return { Domain[] -> Element[] }
   ///         For each statement instance, the array elements that contain the
   ///         same ValInst.
   isl::union_map findSameContentElements(isl::union_map ValInst) {
-    assert(!ValInst.is_single_valued().is_false());
+    assert(ValInst.is_single_valued(isl::quota::ret_true));
 
     // { Domain[] }
     isl::union_set Domain = ValInst.domain();
 
     // { Domain[] -> Scatter[] }
     isl::union_map Schedule = getScatterFor(Domain);
 
     // { Element[] -> [Scatter[] -> ValInst[]] }
isl::map singleLocation(isl::union_map MustKnown, isl::set Domain) {
     // { Domain[] -> Element[] }
     isl::map Result;
 
     // MemoryAccesses can read only elements from a single array
     // (i.e. not: { Dom[0] -> A[0]; Dom[1] -> B[1] }).
     // Look through all spaces until we find one that contains at least the
     // wanted statement instance.s
     bool Aborted = false;
-    MustKnown.foreach_map([&](isl::map Map) -> isl::stat {
+    MustKnown.foreach_map([&](isl::map Map) {
       // Get the array this is accessing.
       if (Aborted)
-        return isl::stat::ok;
+        return;
 
       isl::id ArrayId = Map.get_tuple_id(isl::dim::out);
       ScopArrayInfo *SAI = static_cast<ScopArrayInfo *>(ArrayId.get_user());
 
       // No support for generation of indirect array accesses.
       if (SAI->getBasePtrOriginSAI())
-        return isl::stat::ok; // continue
+        return; // continue
 
       // Determine whether this map contains all wanted values.
       isl::set MapDom = Map.domain();
-      if (!Domain.is_subset(MapDom).is_true())
-        return isl::stat::ok; // continue
+      if (!Domain.is_subset(MapDom, isl::quota::unclear))
+        return; // continue
 
       // There might be multiple array elements that contain the same value, but
       // choose only one of them. lexmin is used because it returns a one-value
       // mapping, we do not care about which one.
       // TODO: Get the simplest access function.
       Result = Map.lexmin();
 
       Aborted = true;
-      return isl::stat::ok; // break
+      return; // break
     });
 
     return Result;
   }
 
 public:
   ForwardOpTreeImpl(Scop *S, LoopInfo *LI, IslMaxOperationsGuard &MaxOpGuard)
       : ZoneAlgorithm("polly-optree", S, LI), MaxOpGuard(MaxOpGuard) {}
if (Access) {
       // { [DomainDef[] -> Value[]] }
       // that it replicates. Instead of  cloning the known content of
       // [DomainDef[] -> Value[]]
       // for DomainTarget[], we add a 'translator' that maps
       // [DomainTarget[] -> Value[]] to [DomainDef[] -> Value[]]
       // before comparing to the known content.
       // TODO: 'Translator' could also be used to map PHINodes to their incoming
       // ValInsts.
-      if (ValInstSpace.is_wrapping()) {
+      if (ValInstSpace.is_wrapping(isl::quota::unclear)) {
         // { DefDomain[] -> Value[] }
         isl::map ValInsts = ExpectedVal.range().unwrap();
 
         // { DefDomain[] }
         isl::set DefDomain = ValInsts.domain();
 
         // { Value[] }
         isl::space ValSpace = ValInstSpace.unwrap().range();

lib/Transform/MaximalStaticExpansion.cpp

 /// i.e. there are two constants Min and Max, such that every value x of the
 /// chosen dimensions is Min <= x <= Max.
 static bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
   auto ParamDims = Set.dim(isl::dim::param);
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
   auto SetDims = Set.dim(isl::dim::set);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
-  return bool(Set.is_bounded());
+  return bool(Set.is_bounded(isl::quota::unclear));
 }
 #endif
 
 char MaximalStaticExpander::ID = 0;
 
 isl::union_map MaximalStaticExpander::filterDependences(
     Scop &S, const isl::union_map &Dependences, MemoryAccess *MA) {
   auto SAI = MA->getLatestScopArrayInfo();
 
   auto AccessDomainSet = MA->getAccessRelation().domain();
   auto AccessDomainId = AccessDomainSet.get_tuple_id();
 
   isl::union_map MapDependences = isl::union_map::empty(S.getParamSpace());
 
   Dependences.foreach_map([&MapDependences, &AccessDomainId,
-                           &SAI](isl::map Map) -> isl::stat {
+                           &SAI](isl::map Map) {
     // Filter out Statement to Statement dependences.
-    if (!Map.can_curry())
-      return isl::stat::ok;
+    if (!Map.can_curry(isl::quota::unclear))
+      return;
 
     // Intersect with the relevant SAI.
     auto TmpMapDomainId =
         Map.get_space().domain().unwrap().range().get_tuple_id(isl::dim::set);
 
     ScopArrayInfo *UserSAI =
         static_cast<ScopArrayInfo *>(TmpMapDomainId.get_user());
 
     if (SAI != UserSAI)
-      return isl::stat::ok;
+      return;
 
     // Get the correct S1[] -> S2[] dependence.
     auto NewMap = Map.factor_domain();
     auto NewMapDomainId = NewMap.domain().get_tuple_id();
 
     if (AccessDomainId.get() != NewMapDomainId.get())
-      return isl::stat::ok;
+      return;
 
     // Add the corresponding map to MapDependences.
     MapDependences = MapDependences.add_map(NewMap);
 
-    return isl::stat::ok;
+    return;
   });
 
   return MapDependences;
 }
 
 bool MaximalStaticExpander::isExpandable(
     const ScopArrayInfo *SAI, SmallPtrSetImpl<MemoryAccess *> &Writes,
     SmallPtrSetImpl<MemoryAccess *> &Reads, Scop &S,
if (SAI->isValueKind()) {
 
     auto Writes = S.getPHIIncomings(SAI);
 
     // Get the domain where all the writes are writing to.
     auto WriteDomain = isl::union_set::empty(S.getParamSpace());
 
     for (auto Write : Writes) {
       auto MapDeps = filterDependences(S, Dependences, Write);
-      MapDeps.foreach_map([&WriteDomain](isl::map Map) -> isl::stat {
+      MapDeps.foreach_map([&WriteDomain](isl::map Map) {
         WriteDomain = WriteDomain.add_set(Map.range());
-        return isl::stat::ok;
+        return;
       });
     }
 
     // For now, read from original scalar is not possible.
-    if (!StmtDomain.is_equal(WriteDomain)) {
+    if (!StmtDomain.is_equal(WriteDomain, isl::quota::unclear)) {
       emitRemark(SAI->getName() + " read from its original value.",
                  Read->getAccessInstruction());
       return false;
     }
 
     return true;
   } else if (SAI->isExitPHIKind()) {
     // For now, we are not able to expand ExitPhi.
for (MemoryAccess *MA : Stmt) {
       if (SAI != MA->getLatestScopArrayInfo())
         continue;
 
       // For now, we are not able to expand array where read come after write
       // (to the same location) in a same statement.
       auto AccRel = isl::union_map(MA->getAccessRelation());
       if (MA->isRead()) {
         // Reject load after store to same location.
-        if (!StmtWrites.is_disjoint(AccRel)) {
+        if (!StmtWrites.is_disjoint(AccRel, isl::quota::unclear)) {
           emitRemark(SAI->getName() + " has read after write to the same "
                                       "element in same statement. The "
                                       "dependences found during analysis may "
                                       "be wrong because Polly is not able to "
                                       "handle such case for now.",
                      MA->getAccessInstruction());
           return false;
         }
for (MemoryAccess *MA : Stmt) {
                          " has too many dependences to be handle for now.",
                      MA->getAccessInstruction());
           return false;
         }
 
         auto DepsDomainSet = isl::set(DepsDomain);
 
         // For now, read from the original array is not possible.
-        if (!StmtDomain.is_subset(DepsDomainSet)) {
+        if (!StmtDomain.is_subset(DepsDomainSet, isl::quota::unclear)) {
           emitRemark("The expansion of " + SAI->getName() +
                          " would lead to a read from the original array.",
                      MA->getAccessInstruction());
           return false;
         }
 
         Reads.insert(MA);
       }
for (auto MA : Accesses) {
     auto DomainSet = MA->getAccessRelation().domain();
     auto Domain = isl::union_set(DomainSet);
 
     // Get the dependences relevant for this MA.
     isl::union_map MapDependences =
         filterDependences(S, Reverse ? Dependences.reverse() : Dependences, MA);
 
     // If no dependences, no need to modify anything.
-    if (MapDependences.is_empty())
+    if (MapDependences.is_empty(isl::quota::unclear))
       return;
 
     assert(isl_union_map_n_map(MapDependences.get()) == 1 &&
            "There are more than one RAW dependencies in the union map.");
     auto NewAccessMap = isl::map::from_union_map(MapDependences);
 
     auto Id = ExpandedSAI->getBasePtrId();
 
ScopArrayInfo *MaximalStaticExpander::expandAccess(Scop &S, MemoryAccess *MA) {
   NewAccessMap = NewAccessMap.set_tuple_id(isl::dim::out, CurrentOutId);
 
   // Create the size vector.
   std::vector<unsigned> Sizes;
   for (unsigned i = 0; i < in_dimensions; i++) {
     assert(isDimBoundedByConstant(CurrentStmtDomain, i) &&
            "Domain boundary are not constant.");
     auto UpperBound = getConstant(CurrentStmtDomain.dim_max(i), true, false);
-    assert(!UpperBound.is_null() && UpperBound.is_pos() &&
-           !UpperBound.is_nan() &&
+    assert(!UpperBound.is_null() && UpperBound.is_pos(isl::quota::ret_true) &&
+           !UpperBound.is_nan(isl::quota::ret_false) &&
            "The upper bound is not a positive integer.");
     assert(UpperBound.le(isl::val(CurrentAccessMap.get_ctx(),
-                                  std::numeric_limits<int>::max() - 1)) &&
+                                  std::numeric_limits<int>::max() - 1),
+                         isl::quota::ret_true) &&
            "The upper bound overflow a int.");
     Sizes.push_back(UpperBound.get_num_si() + 1);
   }
 
   // Get the ElementType of the current SAI.
   auto ElementType = MA->getLatestScopArrayInfo()->getElementType();
 
   // Create (or get if already existing) the new expanded SAI.

lib/Transform/ScheduleOptimizer.cpp

ScheduleTreeOptimizer::standardBandOpts(isl::schedule_node Node, void *User) {
 
   if (PollyVectorizerChoice == VECTORIZER_NONE)
     return Node;
 
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
   auto Dims = Space.dim(isl::dim::set);
 
   for (int i = Dims - 1; i >= 0; i--)
-    if (Node.band_member_get_coincident(i)) {
+    if (Node.band_member_get_coincident(i, isl::quota::unclear)) {
       Node = prevectSchedBand(Node, i, PrevectorWidth);
       break;
     }
 
   return Node;
 }
 
 /// Permute the two dimensions of the isl map.
 ///
 /// Permute @p DstPos and @p SrcPos dimensions of the isl map @p Map that
 /// have type @p DimType.
 ///
 /// @param Map     The isl map to be modified.
 /// @param DimType The type of the dimensions.
 /// @param DstPos  The first dimension.
 /// @param SrcPos  The second dimension.
 /// @return        The modified map.
 isl::map permuteDimensions(isl::map Map, isl::dim DimType, unsigned DstPos,
                            unsigned SrcPos) {
   assert(DstPos < Map.dim(DimType) && SrcPos < Map.dim(DimType));
   if (DstPos == SrcPos)
     return Map;
   isl::id DimId;
-  if (Map.has_tuple_id(DimType))
+  if (Map.has_tuple_id(DimType, isl::quota::unclear))
     DimId = Map.get_tuple_id(DimType);
   auto FreeDim = DimType == isl::dim::in ? isl::dim::out : isl::dim::in;
   isl::id FreeDimId;
-  if (Map.has_tuple_id(FreeDim))
+  if (Map.has_tuple_id(FreeDim, isl::quota::unclear))
     FreeDimId = Map.get_tuple_id(FreeDim);
   auto MaxDim = std::max(DstPos, SrcPos);
   auto MinDim = std::min(DstPos, SrcPos);
   Map = Map.move_dims(FreeDim, 0, DimType, MaxDim, 1);
   Map = Map.move_dims(FreeDim, 0, DimType, MinDim, 1);
   Map = Map.move_dims(DimType, MinDim, FreeDim, 1, 1);
   Map = Map.move_dims(DimType, MaxDim, FreeDim, 0, 1);
   if (DimId)
for (int i = 0; i < 6; i += 1) {
     AccMap = AccMap.intersect_domain(Domain);
     PossibleMatMul = PossibleMatMul.intersect_domain(Domain);
 
     // If AccMap spans entire domain (Non-partial write),
     // compute FirstPos and SecondPos.
     // If AccMap != PossibleMatMul here (the two maps have been gisted at
     // this point), it means that the writes are not complete, or in other
     // words, it is a Partial write and Partial writes must be rejected.
-    if (AccMap.is_equal(PossibleMatMul)) {
+    if (AccMap.is_equal(PossibleMatMul, isl::quota::unclear)) {
       if (FirstPos != -1 && FirstPos != FirstDims[i])
         continue;
       FirstPos = FirstDims[i];
       if (SecondPos != -1 && SecondPos != SecondDims[i])
         continue;
       SecondPos = SecondDims[i];
       return true;
     }
static bool containsOnlyMatMulDep(isl::map Schedule, const Dependences *D,
   if (Red)
     Dep = Dep.unite(Red);
   auto DomainSpace = Schedule.get_space().domain();
   auto Space = DomainSpace.map_from_domain_and_range(DomainSpace);
   auto Deltas = Dep.extract_map(Space).deltas();
   int DeltasDimNum = Deltas.dim(isl::dim::set);
   for (int i = 0; i < DeltasDimNum; i++) {
     auto Val = Deltas.plain_get_val_if_fixed(isl::dim::set, i);
-    Pos = Pos < 0 && Val.is_one() ? i : Pos;
-    if (Val.is_nan() || !(Val.is_zero() || (i == Pos && Val.is_one())))
+    Pos = Pos < 0 && Val.is_one(isl::quota::unclear) ? i : Pos;
+    if (Val.is_nan(isl::quota::unclear) ||
+        !(Val.is_zero(isl::quota::unclear) ||
+          (i == Pos && Val.is_one(isl::quota::unclear))))
       return false;
   }
   if (DeltasDimNum == 0 || Pos < 0)
     return false;
   return true;
 }
 
 /// Check if the SCoP statement could probably be optimized with analytical
bool ScheduleTreeOptimizer::isProfitableSchedule(Scop &S,
   // before/after the scheduling optimizer
   // (e.g., #stride-one accesses)
   if (S.containsExtensionNode(NewSchedule))
     return true;
   auto NewScheduleMap = NewSchedule.get_map();
   auto OldSchedule = S.getSchedule();
   assert(OldSchedule && "Only IslScheduleOptimizer can insert extension nodes "
                         "that make Scop::getSchedule() return nullptr.");
-  bool changed = !OldSchedule.is_equal(NewScheduleMap);
+  bool changed = !OldSchedule.is_equal(NewScheduleMap, isl::quota::unclear);
   return changed;
 }
 
 namespace {
 
 class IslScheduleOptimizer : public ScopPass {
 public:
   static char ID;
isl_schedule_node_foreach_descendant_top_down(
           NumBands[Version]++;
           if (isl_schedule_node_band_get_permutable(Node.get()) ==
               isl_bool_true)
             NumPermutable[Version]++;
 
           int CountMembers = isl_schedule_node_band_n_member(Node.get());
           NumBandMembers[Version] += CountMembers;
           for (int i = 0; i < CountMembers; i += 1) {
-            if (Node.band_member_get_coincident(i))
+            if (Node.band_member_get_coincident(i, isl::quota::unclear))
               NumCoincident[Version]++;
           }
           break;
         }
 
         case isl_schedule_node_filter:
           NumFilters[Version]++;
           break;

lib/Transform/Simplify.cpp

static isl::union_map underapproximatedAddMap(isl::union_map UMap,
   if (isl_map_n_basic_map(PrevMap.get()) + isl_map_n_basic_map(Map.get()) <=
       SimplifyMaxDisjuncts)
     return UMap.add_map(Map);
 
   isl::map Result = isl::map::empty(PrevMap.get_space());
   bool Aborted;
 
   Aborted = false;
-  PrevMap.foreach_basic_map(
-      [&Result, &Aborted](isl::basic_map BMap) -> isl::stat {
-        if (Aborted)
-          return isl::stat::ok;
+  PrevMap.foreach_basic_map([&Result, &Aborted](isl::basic_map BMap) {
+      return;
 
-        if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts) {
-          Aborted = true;
-          return isl::stat::ok;
-        }
-        Result = Result.unite(BMap);
-        return isl::stat::ok;
-      });
+      return;
+    return;
 
   Aborted = false;
-  Map.foreach_basic_map([&Result, &Aborted](isl::basic_map BMap) -> isl::stat {
+  Map.foreach_basic_map([&Result, &Aborted](isl::basic_map BMap) {
     if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts) {
       Aborted = true;
-      return isl::stat::ok;
+      return;
     }
     Result = Result.unite(BMap);
-    return isl::stat::ok;
+    return;
   });
 
   isl::union_map UResult =
       UMap.subtract(isl::map::universe(PrevMap.get_space()));
   UResult.add_map(Result);
 
   return UResult;
 }
for (auto &Stmt : *S) {
           // complex isl sets.
           isl::map AccRelUniv = isl::map::universe(AccRel.get_space());
           WillBeOverwritten = WillBeOverwritten.subtract(AccRelUniv);
           continue;
         }
 
         // If all of a write's elements are overwritten, remove it.
         isl::union_map AccRelUnion = AccRel;
-        if (AccRelUnion.is_subset(WillBeOverwritten)) {
+        if (AccRelUnion.is_subset(WillBeOverwritten, isl::quota::unclear)) {
           DEBUG(dbgs() << "Removing " << MA
                        << " which will be overwritten anyway\n");
 
           Stmt.removeSingleMemoryAccess(MA);
           OverwritesRemoved++;
           TotalOverwritesRemoved[CallNo]++;
         }
 
for (auto &Stmt : *S) {
 
           // Lookup future write that fulfills these conditions.
           // { [[Domain[] -> Element[]] -> Value[]] -> MemoryAccess[] }
           isl::union_map Filtered =
               FutureWrites.uncurry().intersect_domain(Filter.wrap());
 
           // Iterate through the candidates.
           bool Aborted = false;
-          Filtered.foreach_map([&, this](isl::map Map) -> isl::stat {
+          Filtered.foreach_map([&, this](isl::map Map) {
             if (Aborted)
-              return isl::stat::ok;
+              return;
             MemoryAccess *OtherMA = (MemoryAccess *)Map.get_space()
                                         .get_tuple_id(isl::dim::out)
                                         .get_user();
 
             isl::map OtherAccRel =
                 OtherMA->getLatestAccessRelation().intersect_domain(Domain);
 
             // The filter only guaranteed that some of OtherMA's accessed
             // elements are allowed. Verify that it only accesses allowed
             // elements. Otherwise, continue with the next candidate.
-            if (!OtherAccRel.is_subset(AllowedAccesses).is_true())
-              return isl::stat::ok;
+            if (!OtherAccRel.is_subset(AllowedAccesses, isl::quota::unclear))
+              return;
 
             // The combined access relation.
             // { Domain[] -> Element[] }
             isl::map NewAccRel = AccRel.unite(OtherAccRel);
             simplify(NewAccRel);
 
             // Carry out the coalescing.
             Stmt.removeSingleMemoryAccess(MA);
             OtherMA->setNewAccessRelation(NewAccRel);
 
             // We removed MA, OtherMA takes its role.
             MA = OtherMA;
 
             TotalWritesCoalesced[CallNo]++;
             WritesCoalesced++;
 
             // Don't look for more candidates.
             Aborted = true;
-            return isl::stat::ok;
+            return;
           });
         }
 
         // Two writes cannot be coalesced if there is another access (to some of
         // the written elements) between them. Remove all visited write accesses
         // from the list of eligible writes. Don't just remove the accessed
         // elements, but any MemoryAccess that touches any of the invalidated
         // elements.
         SmallPtrSet<MemoryAccess *, 2> TouchedAccesses;
         FutureWrites.intersect_domain(AccRelWrapped)
-            .foreach_map([&TouchedAccesses](isl::map Map) -> isl::stat {
+            .foreach_map([&TouchedAccesses](isl::map Map) {
               MemoryAccess *MA = (MemoryAccess *)Map.get_space()
                                      .range()
                                      .unwrap()
                                      .get_tuple_id(isl::dim::out)
                                      .get_user();
               TouchedAccesses.insert(MA);
-              return isl::stat::ok;
+              return;
             });
         isl::union_map NewFutureWrites =
             isl::union_map::empty(FutureWrites.get_space());
-        FutureWrites.foreach_map([&TouchedAccesses, &NewFutureWrites](
-                                     isl::map FutureWrite) -> isl::stat {
+        FutureWrites.foreach_map(
+            [&TouchedAccesses, &NewFutureWrites](isl::map FutureWrite) {
               MemoryAccess *MA = (MemoryAccess *)FutureWrite.get_space()
                                      .range()
                                      .unwrap()
                                      .get_tuple_id(isl::dim::out)
                                      .get_user();
               if (!TouchedAccesses.count(MA))
                 NewFutureWrites = NewFutureWrites.add_map(FutureWrite);
-          return isl::stat::ok;
+              return;
             });
         FutureWrites = NewFutureWrites;
 
         if (MA->isMustWrite() && !ValSet.is_null()) {
           // { MemoryAccess[] }
           auto AccSet =
               isl::set::universe(isl::space(S->getIslCtx(), 0, 0)
                                      .set_tuple_id(isl::dim::set, MA->getId()));
 
for (auto &Stmt : *S) {
           Value *StoredVal = MA->tryGetValueStored();
           if (!StoredVal)
             StoredVal = MA->getAccessValue();
 
           if (StoredVal) {
             // Lookup in the set of known values.
             isl::map AccRelStoredVal = isl::map::from_domain_and_range(
                 AccRelWrapped, makeValueSet(StoredVal));
-            if (isl::union_map(AccRelStoredVal).is_subset(Known)) {
+            if (isl::union_map(AccRelStoredVal)
+                    .is_subset(Known, isl::quota::unclear)) {
               DEBUG(dbgs() << "Cleanup of " << MA << ":\n");
               DEBUG(dbgs() << "      Scalar: " << *StoredVal << "\n");
               DEBUG(dbgs() << "      AccRel: " << AccRel << "\n");
 
               Stmt.removeSingleMemoryAccess(MA);
 
               RedundantWritesRemoved++;
               TotalRedundantWritesRemoved[CallNo]++;
for (ScopStmt &Stmt : *S) {
       // Defer the actual removal to not invalidate iterators.
       SmallVector<MemoryAccess *, 8> DeferredRemove;
 
       for (MemoryAccess *MA : Stmt) {
         if (!MA->isWrite())
           continue;
 
         isl::map AccRel = MA->getAccessRelation();
-        if (!AccRel.is_empty().is_true())
+        if (!AccRel.is_empty(isl::quota::unclear))
           continue;
 
         DEBUG(dbgs() << "Removing " << MA
                      << " because it's a partial access that never occurs\n");
         DeferredRemove.push_back(MA);
       }
 
       for (MemoryAccess *MA : DeferredRemove) {

lib/Transform/ZoneAlgo.cpp

static isl::map makeUnknownForDomain(isl::set Domain) {
   return isl::map::from_domain(Domain);
 }
 
 /// Return whether @p Map maps to an unknown value.
 ///
 /// @param { [] -> ValInst[] }
 static bool isMapToUnknown(const isl::map &Map) {
   isl::space Space = Map.get_space().range();
-  return Space.has_tuple_id(isl::dim::set).is_false() &&
-         Space.is_wrapping().is_false() && Space.dim(isl::dim::set) == 0;
+  return !Space.has_tuple_id(isl::dim::set, isl::quota::unclear) &&
+         !Space.is_wrapping(isl::quota::unclear) &&
+         Space.dim(isl::dim::set) == 0;
 }
 
 isl::union_map polly::filterKnownValInst(const isl::union_map &UMap) {
   isl::union_map Result = isl::union_map::empty(UMap.get_space());
-  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
+  UMap.foreach_map([=, &Result](isl::map Map) {
     if (!isMapToUnknown(Map))
       Result = Result.add_map(Map);
-    return isl::stat::ok;
+    return;
   });
   return Result;
 }
 
 ZoneAlgorithm::ZoneAlgorithm(const char *PassName, Scop *S, LoopInfo *LI)
     : PassName(PassName), IslCtx(S->getSharedIslCtx()), S(S), LI(LI),
       Schedule(S->getSchedule()) {
   auto Domains = S->getDomains();
for (auto *MA : *Stmt) {
 
     // To avoid solving any ILP problems, always add entire arrays instead of
     // just the elements that are accessed.
     auto ArrayElts = isl::set::universe(AccRelMap.get_space().range());
     AllElts = AllElts.add_set(ArrayElts);
 
     if (MA->isRead()) {
       // Reject load after store to same location.
-      if (!Stores.is_disjoint(AccRel)) {
+      if (!Stores.is_disjoint(AccRel, isl::quota::unclear)) {
         DEBUG(dbgs() << "Load after store of same element in same statement\n");
         OptimizationRemarkMissed R(PassName, "LoadAfterStore",
                                    MA->getAccessInstruction());
         R << "load after store of same element in same statement";
         R << " (previous stores: " << Stores;
         R << ", loading: " << AccRel << ")";
         S->getFunction().getContext().diagnose(R);
 
         IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
       }
 
       Loads = Loads.unite(AccRel);
 
       continue;
     }
 
     // In region statements the order is less clear, eg. the load and store
     // might be in a boxed loop.
-    if (Stmt->isRegionStmt() && !Loads.is_disjoint(AccRel)) {
+    if (Stmt->isRegionStmt() &&
+        !Loads.is_disjoint(AccRel, isl::quota::unclear)) {
       DEBUG(dbgs() << "WRITE in non-affine subregion not supported\n");
       OptimizationRemarkMissed R(PassName, "StoreInSubregion",
                                  MA->getAccessInstruction());
       R << "store is in a non-affine subregion";
       S->getFunction().getContext().diagnose(R);
 
       IncompatibleElts = IncompatibleElts.add_set(ArrayElts);
     }
 
     // Do not allow more than one store to the same location.
-    if (!Stores.is_disjoint(AccRel) && !onlySameValueWrites(Stmt)) {
+    if (!Stores.is_disjoint(AccRel, isl::quota::unclear) &&
+        !onlySameValueWrites(Stmt)) {
       DEBUG(dbgs() << "WRITE after WRITE to same element\n");
       OptimizationRemarkMissed R(PassName, "StoreAfterStore",
                                  MA->getAccessInstruction());
       R << "store after store of same element in same statement";
       R << " (previous stores: " << Stores;
       R << ", storing: " << AccRel << ")";
       S->getFunction().getContext().diagnose(R);
 
isl::union_map ZoneAlgorithm::getWrittenValue(MemoryAccess *MA,
   ScopStmt *Stmt = MA->getStatement();
   Instruction *AccInst = MA->getAccessInstruction();
 
   // Write a value to a single element.
   auto L = MA->isOriginalArrayKind() ? LI->getLoopFor(AccInst->getParent())
                                      : Stmt->getSurroundingLoop();
   if (AccVal &&
       AccVal->getType() == MA->getLatestScopArrayInfo()->getElementType() &&
-      AccRel.is_single_valued().is_true())
+      AccRel.is_single_valued(isl::quota::unclear))
     return makeNormalizedValInst(AccVal, Stmt, L);
 
   // memset(_, '0', ) is equivalent to writing the null value to all touched
   // elements. isMustWrite() ensures that all of an element's bytes are
   // overwritten.
   if (auto *Memset = dyn_cast<MemSetInst>(AccInst)) {
     auto *WrittenConstant = dyn_cast<Constant>(Memset->getValue());
     Type *Ty = MA->getLatestScopArrayInfo()->getElementType();
isl::union_map ZoneAlgorithm::computePerPHI(const ScopArrayInfo *SAI) {
 
   // { DomainPHIRead[] -> Scatter[] }
   isl::map PHIWriteTimes = BeforeRead.intersect_range(WriteTimes);
   isl::map LastPerPHIWrites = PHIWriteTimes.lexmax();
 
   // { DomainPHIRead[] -> DomainPHIWrite[] }
   isl::union_map Result =
       isl::union_map(LastPerPHIWrites).apply_range(PHIWriteScatter.reverse());
-  assert(!Result.is_single_valued().is_false());
-  assert(!Result.is_injective().is_false());
+  assert(Result.is_single_valued(isl::quota::ret_true));
+  assert(Result.is_injective(isl::quota::ret_true));
 
   PerPHIMaps.insert({PHI, Result});
   return Result;
 }
 
 isl::union_set ZoneAlgorithm::makeEmptyUnionSet() const {
   return isl::union_set::empty(ParamSpace);
 }
isl::union_map ZoneAlgorithm::getScatterFor(isl::union_set Domain) const {
   return Schedule.intersect_domain(Domain);
 }
 
 isl::map ZoneAlgorithm::getScatterFor(isl::set Domain) const {
   auto ResultSpace = Domain.get_space().map_from_domain_and_range(ScatterSpace);
   auto UDomain = isl::union_set(Domain);
   auto UResult = getScatterFor(std::move(UDomain));
   auto Result = singleton(std::move(UResult), std::move(ResultSpace));
-  assert(!Result || Result.domain().is_equal(Domain) == isl_bool_true);
+  assert(!Result || Result.domain().is_equal(Domain, isl::quota::ret_true));
   return Result;
 }
 
 isl::set ZoneAlgorithm::getDomainFor(ScopStmt *Stmt) const {
   return Stmt->getDomain().remove_redundancies();
 }
 
 isl::set ZoneAlgorithm::getDomainFor(MemoryAccess *MA) const {

 /// @param Input        { [] -> ValInst[] }
 /// @param ComputedPHIs Set of PHIs that are replaced. Its ValInst must appear
 ///                     on the LHS of @p NormalizeMap.
 /// @param NormalizeMap { ValInst[] -> ValInst[] }
 static isl::union_map normalizeValInst(isl::union_map Input,
                                        const DenseSet<PHINode *> &ComputedPHIs,
                                        isl::union_map NormalizeMap) {
   isl::union_map Result = isl::union_map::empty(Input.get_space());
-  Input.foreach_map(
-      [&Result, &ComputedPHIs, &NormalizeMap](isl::map Map) -> isl::stat {
-        isl::space Space = Map.get_space();
-        isl::space RangeSpace = Space.range();
+  Input.foreach_map([&Result, &ComputedPHIs, &NormalizeMap](isl::map Map) {
 
-        // Instructions within the SCoP are always wrapped. Non-wrapped tuples
-        // are therefore invariant in the SCoP and don't need normalization.
-        if (!RangeSpace.is_wrapping()) {
-          Result = Result.add_map(Map);
-          return isl::stat::ok;
-        }
+    if (!RangeSpace.is_wrapping(isl::quota::unclear)) {
+      return;
 
-        auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(
-            RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user()));
 
-        // If no normalization is necessary, then the ValInst stands for itself.
-        if (!ComputedPHIs.count(PHI)) {
-          Result = Result.add_map(Map);
-          return isl::stat::ok;
-        }
+      return;
 
-        // Otherwise, apply the normalization.
-        isl::union_map Mapped = isl::union_map(Map).apply_range(NormalizeMap);
-        Result = Result.unite(Mapped);
-        NumPHINormialization++;
-        return isl::stat::ok;
-      });
+    return;
   return Result;
 }
 
 isl::union_map ZoneAlgorithm::makeNormalizedValInst(llvm::Value *Val,
                                                     ScopStmt *UserStmt,
                                                     llvm::Loop *Scope,
                                                     bool IsCertain) {
   isl::map ValInst = makeValInst(Val, UserStmt, Scope, IsCertain);
bool ZoneAlgorithm::isNormalizable(MemoryAccess *MA) {
 
   return true;
 }
 
 bool ZoneAlgorithm::isNormalized(isl::map Map) {
   isl::space Space = Map.get_space();
   isl::space RangeSpace = Space.range();
 
-  if (!RangeSpace.is_wrapping())
+  if (!RangeSpace.is_wrapping(isl::quota::unclear))
     return true;
 
   auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(
       RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user()));
   if (!PHI)
     return true;
 
   auto *IncomingStmt = static_cast<ScopStmt *>(
       RangeSpace.unwrap().get_tuple_id(isl::dim::in).get_user());
   MemoryAccess *PHIRead = IncomingStmt->lookupPHIReadOf(PHI);
   if (!isNormalizable(PHIRead))
     return true;
 
   return false;
 }
 
 bool ZoneAlgorithm::isNormalized(isl::union_map UMap) {
   bool IsNormalized = true;
-  UMap.foreach_map([&](isl::map Map) -> isl::stat {
+  UMap.foreach_map([&](isl::map Map) {
     if (!isNormalized(Map))
       IsNormalized = false;
-    return isl::stat::ok;
+    return;
   });
   return IsNormalized;
 }
 
 void ZoneAlgorithm::computeCommon() {
   AllReads = makeEmptyUnionMap();
   AllMayWrites = makeEmptyUnionMap();
   AllMustWrites = makeEmptyUnionMap();
for (MemoryAccess *MA : Stmt) {
       // Determine which instance of the PHI statement corresponds to which
       // incoming value.
       // { PHIDomain[] -> IncomingDomain[] }
       isl::union_map PerPHI = computePerPHI(SAI);
 
       // { PHIValInst[] -> IncomingValInst[] }
       isl::union_map PHIMap =
           PerPHI.apply_domain(PHIValInst).apply_range(IncomingValInsts);
-      assert(!PHIMap.is_single_valued().is_false());
+      assert(PHIMap.is_single_valued(isl::quota::ret_true));
 
       // Resolve transitiveness: The incoming value of the newly discovered PHI
       // may reference a previously normalized PHI. At the same time, already
       // normalized PHIs might be normalized to the new PHI. At the end, none of
       // the PHIs may appear on the right-hand-side of the normalization map.
       PHIMap = normalizeValInst(PHIMap, AllPHIs, AllPHIMaps);
       AllPHIs.insert(PHI);
       AllPHIMaps = normalizeValInst(AllPHIMaps, AllPHIs, PHIMap);

unittests/DeLICM/DeLICMTest.cpp

 using namespace llvm;
 using namespace polly;
 
 namespace {
 
 /// Get the universes of all spaces in @p USet.
 isl::union_set unionSpace(const isl::union_set &USet) {
   auto Result = isl::union_set::empty(USet.get_space());
-  USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
+  USet.foreach_set([=, &Result](isl::set Set) {
     auto Space = Set.get_space();
     auto Universe = isl::set::universe(Space);
     Result = Result.add_set(Universe);
-    return isl::stat::ok;
   });
   return Result;
 }
 
 void completeLifetime(isl::union_set Universe, isl::union_map OccupiedAndKnown,
                       isl::union_set &Occupied, isl::union_map &Known,
                       isl::union_set &Undef) {
   auto ParamSpace = Universe.get_space();
 
   if (Undef && !Occupied) {
     assert(!Occupied);
     Occupied = Universe.subtract(Undef);
   }
 
   if (OccupiedAndKnown) {
     assert(!Known);
 
     Known = isl::union_map::empty(ParamSpace);
 
     if (!Occupied)
       Occupied = OccupiedAndKnown.domain();
 
-    OccupiedAndKnown.foreach_map([&Known](isl::map Map) -> isl::stat {
-      if (!Map.has_tuple_name(isl::dim::out))
-        return isl::stat::ok;
+    OccupiedAndKnown.foreach_map([&Known](isl::map Map) {
+      if (!Map.has_tuple_name(isl::dim::out, isl::quota::unclear))
+        return;
       Known = Known.add_map(Map);
-      return isl::stat::ok;
     });
   }
 
   if (!Undef) {
     assert(Occupied);
     Undef = Universe.subtract(Occupied);
   }
 

unittests/Flatten/FlattenTest.cpp

bool checkFlatten(const char *ScheduleStr, const char *ExpectedStr) {
   auto *Ctx = isl_ctx_alloc();
   bool Success;
 
   {
     auto Schedule = isl::union_map(Ctx, ScheduleStr);
     auto Expected = isl::union_map(Ctx, ExpectedStr);
 
     auto Result = flattenSchedule(std::move(Schedule));
-    Success = Result.is_equal(Expected);
+    Success = Result.is_equal(Expected, isl::quota::unclear);
   }
 
   isl_ctx_free(Ctx);
   return Success;
 }
 
 TEST(Flatten, FlattenTrivial) {
   EXPECT_TRUE(checkFlatten("{ A[] -> [0] }", "{ A[] -> [0] }"));

unittests/Isl/IslTest.cpp

 
 #define USET(Str) isl::union_set(Ctx.get(), Str)
 #define UMAP(Str) isl::union_map(Ctx.get(), Str)
 
 namespace isl {
 inline namespace noexceptions {
 
 static bool operator==(const isl::space &LHS, const isl::space &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::basic_set &LHS, const isl::basic_set &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::set &LHS, const isl::set &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::basic_map &LHS, const isl::basic_map &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::map &LHS, const isl::map &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::union_set &LHS, const isl::union_set &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::union_map &LHS, const isl::union_map &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::val &LHS, const isl::val &RHS) {
-  return bool(LHS.eq(RHS));
+  return bool(LHS.eq(RHS, isl::quota::unclear));
 }
 
 static bool operator==(const isl::pw_aff &LHS, const isl::pw_aff &RHS) {
-  return bool(LHS.is_equal(RHS));
+  return bool(LHS.is_equal(RHS, isl::quota::unclear));
 }
 } // namespace noexceptions
 } // namespace isl
 
 namespace {
 
 TEST(Isl, APIntToIslVal) {
   isl_ctx *IslCtx = isl_ctx_alloc();
 
   {
     APInt APZero(1, 0, true);
     auto IslZero = valFromAPInt(IslCtx, APZero, true);
-    EXPECT_TRUE(IslZero.is_zero());
+    EXPECT_TRUE(IslZero.is_zero(isl::quota::unclear));
   }
 
   {
     APInt APNOne(1, -1, true);
     auto IslNOne = valFromAPInt(IslCtx, APNOne, true);
-    EXPECT_TRUE(IslNOne.is_negone());
+    EXPECT_TRUE(IslNOne.is_negone(isl::quota::unclear));
   }
 
   {
     APInt APZero(1, 0, false);
     auto IslZero = valFromAPInt(IslCtx, APZero, false);
-    EXPECT_TRUE(IslZero.is_zero());
+    EXPECT_TRUE(IslZero.is_zero(isl::quota::unclear));
   }
 
   {
     APInt APOne(1, 1, false);
     auto IslOne = valFromAPInt(IslCtx, APOne, false);
-    EXPECT_TRUE(IslOne.is_one());
+    EXPECT_TRUE(IslOne.is_one(isl::quota::unclear));
   }
 
   {
     APInt APNTwo(2, -2, true);
     auto IslNTwo = valFromAPInt(IslCtx, APNTwo, true);
     auto IslNTwoCmp = isl::val(IslCtx, -2);
     EXPECT_EQ(IslNTwo, IslNTwoCmp);
   }
 
   {
     APInt APNOne(32, -1, true);
     auto IslNOne = valFromAPInt(IslCtx, APNOne, true);
-    EXPECT_TRUE(IslNOne.is_negone());
+    EXPECT_TRUE(IslNOne.is_negone(isl::quota::unclear));
   }
 
   {
     APInt APZero(32, 0, false);
     auto IslZero = valFromAPInt(IslCtx, APZero, false);
-    EXPECT_TRUE(IslZero.is_zero());
+    EXPECT_TRUE(IslZero.is_zero(isl::quota::unclear));
   }
 
   {
     APInt APOne(32, 1, false);
     auto IslOne = valFromAPInt(IslCtx, APOne, false);
-    EXPECT_TRUE(IslOne.is_one());
+    EXPECT_TRUE(IslOne.is_one(isl::quota::unclear));
   }
 
   {
     APInt APTwo(32, 2, false);
     auto IslTwo = valFromAPInt(IslCtx, APTwo, false);
     EXPECT_EQ(0, IslTwo.cmp_si(2));
   }
 
// Remainder
     EXPECT_EQ(AffFour % -3, AffOne);
   }
 }
 
 TEST(Isl, Foreach) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
+  /*
   auto MapSpace = isl::space(Ctx.get(), 0, 1, 1);
   auto TestBMap = isl::basic_map::universe(MapSpace);
   TestBMap = TestBMap.fix_si(isl::dim::out, 0, 0);
   TestBMap = TestBMap.fix_si(isl::dim::out, 0, 0);
   isl::map TestMap = TestBMap;
   isl::union_map TestUMap = TestMap;
 
   auto SetSpace = isl::space(Ctx.get(), 0, 1);
isl::union_set TestUSet = TestSet;
     TestPwAff.foreach_piece([&](isl::set Domain, isl::aff Aff) -> isl::stat {
       EXPECT_EQ(Domain, TestSet);
       EXPECT_TRUE(Aff.is_cst());
       NumPieces++;
       return isl::stat::error;
     });
     EXPECT_EQ(1, NumPieces);
   }
+  */
 }
 
 TEST(ISLTools, beforeScatter) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
   // Basic usage with isl_map
   EXPECT_EQ(MAP("{ [] -> [i] : i <= 0 }"),

unittests/ScheduleOptimizer/ScheduleOptimizerTest.cpp

isl_ctx *ctx = isl_ctx_alloc();
     // Verify that for a loop with 3 iterations starting at 0 that is
     // pre-vectorized (strip-mined with a factor of 2), we correctly identify
     // that only the first two iterations are full vector iterations.
     isl::map Schedule(
         ctx, "{[i] -> [floor(i/2), i - 2 * floor(i/2)] : 0 <= i < 3 }");
     isl::set ScheduleRange = Schedule.range();
     isl::set Result = getPartialTilePrefixes(ScheduleRange, 2);
 
-    EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[0]}")));
+    EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[0]}"), isl::quota::unclear));
   }
 
   {
     // Verify that for a loop with 3 iterations starting at 1 that is
     // pre-vectorized (strip-mined with a factor of 2), we correctly identify
     // that only the last two iterations are full vector iterations.
     isl::map Schedule(
         ctx, "{[i] -> [floor(i/2), i - 2 * floor(i/2)] : 1 <= i < 4 }");
     isl::set ScheduleRange = Schedule.range();
     isl::set Result = getPartialTilePrefixes(ScheduleRange, 2);
 
-    EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[1]}")));
+    EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[1]}"), isl::quota::unclear));
   }
 
   {
     // Verify that for a loop with 6 iterations starting at 1 that is
     // pre-vectorized (strip-mined with a factor of 2), we correctly identify
     // that all but the first and the last iteration are full vector iterations.
     isl::map Schedule(
         ctx, "{[i] -> [floor(i/2), i - 2 * floor(i/2)] : 1 <= i < 6 }");
     isl::set ScheduleRange = Schedule.range();
     isl::set Result = getPartialTilePrefixes(ScheduleRange, 2);
 
-    EXPECT_TRUE(Result.is_equal(isl::set(ctx, "{[1]; [2]}")));
+    EXPECT_TRUE(
+        Result.is_equal(isl::set(ctx, "{[1]; [2]}"), isl::quota::unclear));
   }
 
   isl_ctx_free(ctx);
 }
 } // anonymous namespace