[Polly][Isl] Move to the new-polly-generator branch version of isl-noexceptions.h. NFCI

[patacca]

Summary

This is part of an effort to reduce the differences between the custom C++ bindings used right now by polly in lib/External/isl/include/isl/isl-noxceptions.h and the official isl C++ interface.

With this commit we are moving from the polly-generator branch to the new-polly-generator branch that is more mantainable and is based on the official C++ interface cpp-checked.h.

Changes made:

• There are now many sublcasses for isl::ast_node representing different isl types. Use isl::ast_node_for, isl::ast_node_user, isl::ast_node_block and isl::ast_node_mark where needed.
• There are now many sublcasses for isl::schedule_node representing different isl types. Use isl::schedule_node_mark, isl::schedule_node_extension, isl::schedule_node_band and isl::schedule_node_filter where needed.
• Replace the isl::*::dump with dumpIslObj since the isl dump method is not exposed in the C++ interface.
• isl::schedule_node::get_child has been renamed to isl::schedule_node::child
• isl::pw_multi_aff::get_pw_aff has been renamed to isl::pw_multi_aff::at
• The constructor isl::union_map(isl::union_pw_multi_aff) has been replaced with the static method isl::union_map::from()
• Replace usages of isl::val::add_ui with isl::val::add
• isl::union_set_list::alloc is now a constructor
• All the isl_size values are now wrapped inside the class isl::size use isl::size::release to get the internal isl_size value where needed.
• isl-noexceptions.h has been generated by https://github.com/patacca/isl/commit/73f5ed1f4d1f72582f731590ef9e43d9ab1956ad

No functional change intended.

[patacca]

Revert unrelated change

[patacca]

Add error checks for methods with callbacks in isl-noexceptions.h
This is to remove the warnings during compilation

[Meinersbur]

Thanks for all the effort. Unfortunately the boolean class had a reason to exist. For instance, with isl_set_empty there are 3 possible outcomes:

• true if the set is empty
• false if the set contains at least one element
• error if the result could not be computed, for instance because the argument is NULL or the max_operations counter has been exceeded.

In cpp.h, with exceptions disabled, the 3rd case aborts the program. The argument being NULL could be tested before calling the method, but there is no means to determine whether the max_operations counter is going to be exceeded in the next call. We don't want to crash but to execute some bail-out code. I expected some tests to fail.
cpp-checked.h still has a boolean class and I think there is no way around using it instead of cpp.h. In contrast to isl-noexceptions.h's boolean, the checked on requires the boolean state to be checked for errors to avoid that an error state is accidentally interpreted that same way as true if used like this:

isl::boolean = isl_bool_error;
if (b) {
  ...
}

I might have given the impression that cpp.h is what we need; at that time I though cpp.h was just boolean::checked, but it is missing the entire boolean class.

polly/include/polly/Support/GICHelper.h

189

With isl being a C API and the official C++ binding not having a dump() method, there is nothing " dump() method" could refer to.

[patacca]

• Use isl-noexceptions.h based on cpp-checked.h (https://github.com/patacca/isl/commit/460868053656e29400c69adfc159f15d5a0a6907)
• Use isl::size::release to get the internal isl_size value
• Switch back to isl::boolean

[patacca]

Fix comment for ISL_DUMP_OBJECT

[patacca]

Fix some typo

[Meinersbur]

Thanks for the update.

The checked property is annoying, especially for isl::size. For projects that use assert such as LLVM, the would be that under correct usage no error occurs and if it still does, it is a bug. That is, errors would only be checked explicitly in LLVM_ENABLE_ASSERTIONS=ON builds and otherwise assumed to not occur. the checked property forces us to always check for an error (or use release() as you did). Unfortunately, we cannot just use assert(!Ndims.is_error()) since in non-Assert builds that code will be removed and checked no set to false.

Within an IslMaxOperations scope, checked is actually useful since we cannot exhaustively test when the limit is reached and the property would ensures that we consider a bailout control flow. release() also ignores that.

Did you consider instead of just calling release() everywhere, to introduce and "assert" that is not removed in release builds? Such as

void IslAssertNoError(isl::size &S) {
#ifdef NDEBUG
  // Don't force error checking in non-debug builds.
  S.is_error();
#else
  // Assert on error in debug builds.
  assert(!S.is_error());
#endif
}

In functions that can can be called in an max-operations scope, we would instead use:

if (S.is_error())
  return {}; // Or whatever represents the bailout control flow.

Before accepting, I want to run the patch on the llvm-test-suite where some of the max-operations conditions exceed.

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

202–217

[not a change request] Includes in the middle of the file are usually discouraged as it makes its content dependent on where it is included and things like precompiled headers and module impossible.

cpp-checked.h does this for some reason, which means at most we suggest upstream to change that.

polly/lib/Support/GICHelper.cpp

240–245

Not all the classes are exported/needed?

[patacca]

polly/lib/Support/GICHelper.cpp

240–245

Some classes have been removed from the interface and were not used anywhere in polly. These are ast_expr_list, constraint_list, pw_qpolynomial, qpolynomial, union_map_list and union_pw_multi_aff_list

[patacca]

Rebase to main

Merge commit 50eaa82cdbc72588f0841658bbad9695855eba85 "[Polly][test] Test difference between isl::stat:ok() and isl::stat::error()." and 0f50ffb3365eefaf114f3d1de6e8acee4fe8f169 "[Polly][test] Add tests for IslMaxOperationsGuard."

[patacca]

Add IslAssertNoError and replace some usage of isl::size::release
Add the utility function rangeIslSize
Retype MaxDisjunctsInDomain from int to unsigned
Retype RunTimeChecksMaxAccessDisjuncts from int to unsigned
Add the operators to check the equality and the inequality of two isl::size
The function getNumScatterDims now returns an unsigned instead of isl_size

This is a first patch to use IslAssertNoError instead of isl::size::release

[patacca]

Move definition of polly::rangeIslSize outside the scope for debug builds

[Meinersbur]

I don't see when you are using isl::size::release() and when IslAssertNoError. We talked about a follow-up patch for the assertions, but what is the concept for this patch?
Is it somehow possible to void the static_cast<unsigned> from isl::size? Part of the solution might be to make islAssertNoError return the unsigned result, as we talked about yesterday.

I tested the patch with the SPEC CPU benchmarks. We have one compilation failing which is 526.blender_r/src/blender/source/blender/editors/space_logic/logic_ops.c. Depending on how clang is invoked, it either compiles forever/for too long or crashes with an isl-internal error. It does so even without this patch so it is unrelated. Surprisingly, it happens in a relatively simple call of isl_set_gist_params in Scop::realignParams() with the arguments:

InvalidDomain = [p_0] -> {
  [] : p_0 >= 128 and -1 + p_0 <= 128*floor((64 + p_0)/128) <= p_0 and -255 + p_0 <= 32768*floor((16384 + p_0)/32768) <= p_0 and -65535 + p_0 <= 4194304*floor((2097152 + p_0)/4194304) <= p_0
}
Ctx = [p_0] -> {
   : -2147483648 <= p_0 <= 2147483647
}

I suspect this snug in in an update of ISL. I will try to reproduce it and send a bug report to isl-development. Nothing to do for this patch.

polly/include/polly/Support/ISLTools.h

26

"Lint: Pre-merge checks" is correct, we use camelCase for functions. Maybe you also have an idea for a better name than my suggestion.

535

The asymmetry between the types of Begin and End bugs me. If Begin is always supposed to be 0, did you consider dropping the Begin parameter?

636

[nit] unrelated whitespace change

polly/lib/Analysis/ScopBuilder.cpp

1173–1175

Use IslAssertNoError?

[patacca]

In D107225#2939965, @Meinersbur wrote:

I don't see when you are using isl::size::release() and when IslAssertNoError. We talked about a follow-up patch for the assertions, but what is the concept for this patch?
Is it somehow possible to void the static_cast<unsigned> from isl::size? Part of the solution might be to make islAssertNoError return the unsigned result, as we talked about yesterday.

My idea was to rename and maybe reimplement the IslAssertNoError in a different patch because this one is getting pretty big and has already a lot of changes.
I know that in the last meeting we agreed to include both IslAssertNoError and isl::size::release in this patch but I am now thinking of landing the patch withouth the IslAssertNoError and opening a new one in which the assertion and the casting to unsigned is better handled. Is it ok?

I tested the patch with the SPEC CPU benchmarks. We have one compilation failing which is 526.blender_r/src/blender/source/blender/editors/space_logic/logic_ops.c. Depending on how clang is invoked, it either compiles forever/for too long or crashes with an isl-internal error. It does so even without this patch so it is unrelated. Surprisingly, it happens in a relatively simple call of isl_set_gist_params in Scop::realignParams() with the arguments:

InvalidDomain = [p_0] -> {
  [] : p_0 >= 128 and -1 + p_0 <= 128*floor((64 + p_0)/128) <= p_0 and -255 + p_0 <= 32768*floor((16384 + p_0)/32768) <= p_0 and -65535 + p_0 <= 4194304*floor((2097152 + p_0)/4194304) <= p_0
}
Ctx = [p_0] -> {
   : -2147483648 <= p_0 <= 2147483647
}

I suspect this snug in in an update of ISL. I will try to reproduce it and send a bug report to isl-development. Nothing to do for this patch.

I've run the llvm-test-suite and I also got a single failing test case: MultiSource/Applications/lambda-0.1.3/lambda.test
I am still unsure if it is related to this patch or not but I am investigating

polly/include/polly/Support/ISLTools.h

535

I've put the Begin parameter just for convenience: sometimes (ScopInfo.cpp:681 for example) we start the iteration from a different value. I can remove it if you think it's better

polly/lib/Analysis/ScopBuilder.cpp

1173–1175

I thought that since this one is a stronger assertion I could just remove the IslAssertNoError.
We aren't getting the call to isl::size::is_error though so it might be better to add it anyway

[Meinersbur]

In D107225#2940080, @patacca wrote:

In D107225#2939965, @Meinersbur wrote:

I don't see when you are using isl::size::release() and when IslAssertNoError. We talked about a follow-up patch for the assertions, but what is the concept for this patch?
Is it somehow possible to void the static_cast<unsigned> from isl::size? Part of the solution might be to make islAssertNoError return the unsigned result, as we talked about yesterday.

My idea was to rename and maybe reimplement the IslAssertNoError in a different patch because this one is getting pretty big and has already a lot of changes.
I know that in the last meeting we agreed to include both IslAssertNoError and isl::size::release in this patch but I am now thinking of landing the patch withouth the IslAssertNoError and opening a new one in which the assertion and the casting to unsigned is better handled. Is it ok?

Yes, that would be great.

I've run the llvm-test-suite and I also got a single failing test case: MultiSource/Applications/lambda-0.1.3/lambda.test
I am still unsure if it is related to this patch or not but I am investigating

It is not related to this patch, it failed before as well. See http://meinersbur.de:8011/#/builders/76/builds/337
(I added -mllvm -polly-process-unprofitable to the builder, then the failures showed up; It wasn't testing -mllvm -polly-process-unprofitable before that).

[patacca]

Revert back to diff 7 (id 365038)

[patacca]

The patch has been tested with the llvm-test-suite and it is passing all the tests except for MultiSource/Applications/lambda-0.1.3/lambda.test but as previously stated the failure is not related to this patch.
If it looks good I will land this revision.

[Meinersbur]

LGTM

polly/include/polly/CodeGen/IslNodeBuilder.h

protected:
   //
   //    It must not be calculated at each loop iteration and can often even be
   //    hoisted out further by the loop invariant code motion.
   //
   // 2. OpenMP needs a loop invariant upper bound to calculate the number
   //    of loop iterations.
   //
   // 3. With the existing code, upper bounds have been easier to implement.
-  isl::ast_expr getUpperBound(isl::ast_node For, CmpInst::Predicate &Predicate);
+  isl::ast_expr getUpperBound(isl::ast_node_for For,
+                              CmpInst::Predicate &Predicate);
 
   /// Return non-negative number of iterations in case of the following form
   /// of a loop and -1 otherwise.
   ///
   /// for (i = 0; i <= NumIter; i++) {
   ///   loop body;
   /// }
   ///
   /// NumIter is a non-negative integer value. Condition can have
   /// isl_ast_op_lt type.
-  int getNumberOfIterations(isl::ast_node For);
+  int getNumberOfIterations(isl::ast_node_for For);
 
   /// Compute the values and loops referenced in this subtree.
   ///
   /// This function looks at all ScopStmts scheduled below the provided For node
   /// and finds the llvm::Value[s] and llvm::Loops[s] which are referenced but
   /// not locally defined.
   ///
   /// Values that can be synthesized or that are available as globals are
protected:
   /// This function will preload the representing load from @p IAClass and
   /// map all members of @p IAClass to that preloaded value, potentially casted
   /// to the required type.
   ///
   /// @returns False, iff a problem occurred and the load was not preloaded.
   bool preloadInvariantEquivClass(InvariantEquivClassTy &IAClass);
 
   void createForVector(__isl_take isl_ast_node *For, int VectorWidth);
-  void createForSequential(isl::ast_node For, bool MarkParallel);
+  void createForSequential(isl::ast_node_for For, bool MarkParallel);
 
   /// Create LLVM-IR that executes a for node thread parallel.
   ///
   /// @param For The FOR isl_ast_node for which code is generated.
   void createForParallel(__isl_take isl_ast_node *For);
 
   /// Create new access functions for modified memory accesses.
   ///

polly/include/polly/ScheduleTreeTransform.h

 //===- polly/ScheduleTreeTransform.h ----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Make changes to isl's schedule tree data structure.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_SCHEDULETREETRANSFORM_H
 #define POLLY_SCHEDULETREETRANSFORM_H
 
+#include "polly/Support/ISLTools.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "isl/isl-noexceptions.h"
 #include <cassert>
 
 namespace polly {
 struct BandAttr;
 
struct RecursiveScheduleTreeVisitor
   // Necessary to allow overload resolution with the added visit(isl::schedule)
   // overload.
   RetTy visit(const isl::schedule_node &Node, Args... args) {
     return getBase().visit(Node, std::forward<Args>(args)...);
   }
 
   /// By default, recursively visit the child nodes.
   RetTy visitNode(const isl::schedule_node &Node, Args... args) {
-    isl_size NumChildren = Node.n_children();
-    for (isl_size i = 0; i < NumChildren; i += 1)
+    isl::size NumChildren = Node.n_children();
+    IslAssertNoError(NumChildren);
+    for (unsigned i = 0; i < static_cast<unsigned>(NumChildren); i += 1)
       getDerived().visit(Node.child(i), std::forward<Args>(args)...);
     return RetTy();
   }
 };
 
 /// Is this node the marker for its parent band?
 bool isBandMark(const isl::schedule_node &Node);
 

polly/include/polly/ScopInfo.h

 
 //===---------------------------------------------------------------------===//
 
 extern bool UseInstructionNames;
 
 // The maximal number of basic sets we allow during domain construction to
 // be created. More complex scops will result in very high compile time and
 // are also unlikely to result in good code.
-extern int const MaxDisjunctsInDomain;
+extern unsigned const MaxDisjunctsInDomain;
 
 /// The different memory kinds used in Polly.
 ///
 /// We distinguish between arrays and various scalar memory objects. We use
 /// the term ``array'' to describe memory objects that consist of a set of
 /// individual data elements arranged in a multi-dimensional grid. A scalar
 /// memory object describes an individual data element and is used to model
 /// the definition and uses of llvm::Values.

polly/include/polly/Support/GICHelper.h

 ISL_OBJECT_TO_STRING(union_access_info)
 ISL_OBJECT_TO_STRING(union_flow)
 ISL_OBJECT_TO_STRING(union_set)
 ISL_OBJECT_TO_STRING(union_map)
 ISL_OBJECT_TO_STRING(union_pw_aff)
 ISL_OBJECT_TO_STRING(union_pw_multi_aff)
 //@}
 
+/// C++ wrapper for isl_*_dump() functions.
+//@{
+#define ISL_DUMP_OBJECT(name)                                                  \
+  inline void dumpIslObj(const isl::name &Obj) { isl_##name##_dump(Obj.get()); }
+
+ISL_DUMP_OBJECT(aff)
+ISL_DUMP_OBJECT(aff_list)
+ISL_DUMP_OBJECT(ast_expr)
+ISL_DUMP_OBJECT(ast_node)
+ISL_DUMP_OBJECT(ast_node_list)
+ISL_DUMP_OBJECT(basic_map)
+ISL_DUMP_OBJECT(basic_map_list)
+ISL_DUMP_OBJECT(basic_set)
+ISL_DUMP_OBJECT(basic_set_list)
+ISL_DUMP_OBJECT(constraint)
+ISL_DUMP_OBJECT(id)
+ISL_DUMP_OBJECT(id_list)
+ISL_DUMP_OBJECT(id_to_ast_expr)
+ISL_DUMP_OBJECT(local_space)
+ISL_DUMP_OBJECT(map)
+ISL_DUMP_OBJECT(map_list)
+ISL_DUMP_OBJECT(multi_aff)
+ISL_DUMP_OBJECT(multi_pw_aff)
+ISL_DUMP_OBJECT(multi_union_pw_aff)
+ISL_DUMP_OBJECT(multi_val)
+ISL_DUMP_OBJECT(point)
+ISL_DUMP_OBJECT(pw_aff)
+ISL_DUMP_OBJECT(pw_aff_list)
+ISL_DUMP_OBJECT(pw_multi_aff)
+ISL_DUMP_OBJECT(schedule)
+ISL_DUMP_OBJECT(schedule_constraints)
+ISL_DUMP_OBJECT(schedule_node)
+ISL_DUMP_OBJECT(set)
+ISL_DUMP_OBJECT(set_list)
+ISL_DUMP_OBJECT(space)
+ISL_DUMP_OBJECT(union_map)
+ISL_DUMP_OBJECT(union_pw_aff)
+ISL_DUMP_OBJECT(union_pw_aff_list)
+ISL_DUMP_OBJECT(union_pw_multi_aff)
+ISL_DUMP_OBJECT(union_set)
+ISL_DUMP_OBJECT(union_set_list)
+ISL_DUMP_OBJECT(val)
+ISL_DUMP_OBJECT(val_list)
+//@}
+
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_union_map *Map) {
   OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_map *Map) {

polly/include/polly/Support/ISLTools.h

 //===------ ISLTools.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Tools, utilities, helpers and extensions useful in conjunction with the
 // Integer Set Library (isl).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_ISLTOOLS_H
 #define POLLY_ISLTOOLS_H
 
+#include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/iterator.h"
 #include "isl/isl-noexceptions.h"
+#include <cassert>
+
+namespace polly {
+
+/// In debug builds assert that the @p Size is valid, in non-debug builds
+/// disable the mandatory state checking but do not enforce the error checking.
+inline void IslAssertNoError(const isl::size &Size) {
+#ifdef NDEBUG
+  // Don't force error checking in non-debug builds.
+  Size.is_error();
+#else
+  // Assert on error in debug builds.
+  assert(!Size.is_error());
+#endif
+}
+
+} // namespace polly
 
 namespace isl {
 inline namespace noexceptions {
 
 template <typename ListT>
 using list_element_type = decltype(std::declval<ListT>().get_at(0));
 
 template <typename ListT>
 struct isl_iterator
     : public llvm::iterator_facade_base<isl_iterator<ListT>,
                                         std::forward_iterator_tag,
                                         list_element_type<ListT>> {
 
   using ElementT = list_element_type<ListT>;
 
   explicit isl_iterator(const ListT &List)
-      : List(&List), Position(std::max(List.size(), 0)) {}
+      : List(&List), Position(std::max(List.size().release(), 0)) {}
   isl_iterator(const ListT &List, int Position)
       : List(&List), Position(Position) {}
 
   bool operator==(const isl_iterator &O) const {
     return List == O.List && Position == O.Position;
   }
 
   isl_iterator &operator++() {

 
 template <typename T> isl_iterator<T> begin(const T &t) {
   return isl_iterator<T>(t, 0);
 }
 template <typename T> isl_iterator<T> end(const T &t) {
   return isl_iterator<T>(t);
 }
 
+inline bool operator==(const isl::size &A, const isl::size &B) {
+  polly::IslAssertNoError(A);
+  polly::IslAssertNoError(B);
+  return static_cast<unsigned>(A) == static_cast<unsigned>(B);
+}
+
+inline bool operator!=(const isl::size &A, const isl::size &B) {
+  polly::IslAssertNoError(A);
+  polly::IslAssertNoError(B);
+  return static_cast<unsigned>(A) != static_cast<unsigned>(B);
+}
+
 } // namespace noexceptions
 } // namespace isl
 
 namespace polly {
-
 /// Return the range elements that are lexicographically smaller.
 ///
 /// @param Map    { Space[] -> Scatter[] }
 /// @param Strict True for strictly lexicographically smaller elements (exclude
 ///               same timepoints from the result).
 ///
 /// @return { Space[] -> Scatter[] }
 ///         A map to all timepoints that happen before the timepoints the input

 /// Determine how many dimensions the scatter space of @p Schedule has.
 ///
 /// The schedule must not be empty and have equal number of dimensions of any
 /// subspace it contains.
 ///
 /// The implementation currently returns the maximum number of dimensions it
 /// encounters, if different, and 0 if none is encountered. However, most other
 /// code will most likely fail if one of these happen.
-isl_size getNumScatterDims(const isl::union_map &Schedule);
+unsigned getNumScatterDims(const isl::union_map &Schedule);
 
 /// Return the scatter space of a @p Schedule.
 ///
 /// This is basically the range space of the schedule map, but harder to
 /// determine because it is an isl_union_map.
 isl::space getScatterSpace(const isl::union_map &Schedule);
 
 /// Construct an identity map for the given domain values.

 /// value. Otherwise, return NaN.
 isl::val getConstant(isl::pw_aff PwAff, bool Max, bool Min);
 
 /// Dump a description of the argument to llvm::errs().
 ///
 /// In contrast to isl's dump function, there are a few differences:
 /// - Each polyhedron (pieces) is written on its own line.
 /// - Spaces are sorted by structure. E.g. maps with same domain space are
 ///   grouped. Isl sorts them according to the space's hash function.
 /// - Pieces of the same space are sorted using their lower bound.
 /// - A more compact to_str representation is used instead of Isl's dump
 ///   functions that try to show the internal representation.
 ///
 /// The goal is to get a better understandable representation that is also
 /// useful to compare two sets. As all dump() functions, its intended use is to
 /// be called in a debugger only.
 ///

 void dumpExpanded(const isl::map &Map);
 void dumpExpanded(const isl::union_set &USet);
 void dumpExpanded(const isl::union_map &UMap);
 void dumpExpanded(__isl_keep isl_set *Set);
 void dumpExpanded(__isl_keep isl_map *Map);
 void dumpExpanded(__isl_keep isl_union_set *USet);
 void dumpExpanded(__isl_keep isl_union_map *UMap);
 /// @}
+
+/// Check that @p End is valid and return an iterator from @p Begin to @p End
+///
+/// Use case example:
+///   for (unsigned i : rangeIslSize(0, Map.domain_tuple_dim()))
+///     // do stuff
+llvm::iota_range<unsigned> rangeIslSize(unsigned Begin, isl::size End);
+
 } // namespace polly
 
 #endif /* POLLY_ISLTOOLS_H */

polly/lib/Analysis/DependenceInfo.cpp

static void collectInfo(Scop &S, isl_union_map *&Read,
   ReductionTagMap = isl_union_map_coalesce(ReductionTagMap);
   Read = isl_union_map_coalesce(Read);
   MustWrite = isl_union_map_coalesce(MustWrite);
   MayWrite = isl_union_map_coalesce(MayWrite);
 }
 
 /// Fix all dimension of @p Zero to 0 and add it to @p user
 static void fixSetToZero(isl::set Zero, isl::union_set *User) {
-  for (auto i : seq<isl_size>(0, Zero.tuple_dim()))
+  isl::size Size = Zero.tuple_dim();
+  IslAssertNoError(Size);
+  for (auto i : seq<unsigned>(0, static_cast<unsigned>(Size)))
     Zero = Zero.fix_si(isl::dim::set, i, 0);
   *User = User->unite(Zero);
 }
 
 /// Compute the privatization dependences for a given dependency @p Map
 ///
 /// Privatization dependences are widened original dependences which originate
 /// or end in a reduction access. To compute them we apply the transitive close
for (ScopStmt &Stmt : S) {
 
     Schedule = Schedule.unite(StmtScat);
   }
 
   Dependences = Dependences.apply_domain(Schedule);
   Dependences = Dependences.apply_range(Schedule);
 
   isl::set Zero = isl::set::universe(ScheduleSpace);
-  for (auto i : seq<isl_size>(0, Zero.tuple_dim()))
+  isl::size ZeroDim = Zero.tuple_dim();
+  IslAssertNoError(ZeroDim);
+  for (auto i : seq<unsigned>(0, static_cast<unsigned>(ZeroDim)))
     Zero = Zero.fix_si(isl::dim::set, i, 0);
 
   isl::union_set UDeltas = Dependences.deltas();
   isl::set Deltas = singleton(UDeltas, ScheduleSpace);
 
   isl::space Space = Deltas.get_space();
   isl::map NonPositive = isl::map::universe(Space.map_from_set());
   NonPositive =

polly/lib/Analysis/ScopBuilder.cpp

PollyIgnoreInbounds("polly-ignore-inbounds",
                         cl::desc("Do not take inbounds assumptions at all"),
                         cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
 static cl::opt<unsigned> RunTimeChecksMaxArraysPerGroup(
     "polly-rtc-max-arrays-per-group",
     cl::desc("The maximal number of arrays to compare in each alias group."),
     cl::Hidden, cl::ZeroOrMore, cl::init(20), cl::cat(PollyCategory));
 
-static cl::opt<int> RunTimeChecksMaxAccessDisjuncts(
+static cl::opt<unsigned> RunTimeChecksMaxAccessDisjuncts(
     "polly-rtc-max-array-disjuncts",
     cl::desc("The maximal number of disjunts allowed in memory accesses to "
              "to build RTCs."),
     cl::Hidden, cl::ZeroOrMore, cl::init(8), cl::cat(PollyCategory));
 
 static cl::opt<unsigned> RunTimeChecksMaxParameters(
     "polly-rtc-max-parameters",
     cl::desc("The maximal number of parameters allowed in RTCs."), cl::Hidden,

 /// This map maps from SetSpace -> SetSpace where the dimensions @p Dim
 /// is incremented by one and all other dimensions are equal, e.g.,
 ///             [i0, i1, i2, i3] -> [i0, i1, i2 + 1, i3]
 ///
 /// if @p Dim is 2 and @p SetSpace has 4 dimensions.
 static isl::map createNextIterationMap(isl::space SetSpace, unsigned Dim) {
   isl::space MapSpace = SetSpace.map_from_set();
   isl::map NextIterationMap = isl::map::universe(MapSpace);
-  for (auto u : seq<isl_size>(0, NextIterationMap.domain_tuple_dim()))
-    if (u != (isl_size)Dim)
+  for (auto u : rangeIslSize(0, NextIterationMap.domain_tuple_dim()))
+    if (u != Dim)
       NextIterationMap =
           NextIterationMap.equate(isl::dim::in, u, isl::dim::out, u);
   isl::constraint C =
       isl::constraint::alloc_equality(isl::local_space(MapSpace));
   C = C.set_constant_si(1);
   C = C.set_coefficient_si(isl::dim::in, Dim, 1);
   C = C.set_coefficient_si(isl::dim::out, Dim, -1);
   NextIterationMap = NextIterationMap.add_constraint(C);

 }
 
 /// Compute the (un)bounded parts of @p S wrt. to dimension @p Dim.
 ///
 /// @returns A separation of @p S into first an unbounded then a bounded subset,
 ///          both with regards to the dimension @p Dim.
 static std::pair<isl::set, isl::set> partitionSetParts(isl::set S,
                                                        unsigned Dim) {
-  for (unsigned u = 0, e = S.tuple_dim(); u < e; u++)
+  for (unsigned u : rangeIslSize(0, S.tuple_dim()))
     S = S.lower_bound_si(isl::dim::set, u, 0);
 
-  unsigned NumDimsS = S.tuple_dim();
+  isl::size SDim = S.tuple_dim();
+  IslAssertNoError(SDim);
+  unsigned NumDimsS = static_cast<unsigned>(SDim);
   isl::set OnlyDimS = S;
 
   // Remove dimensions that are greater than Dim as they are not interesting.
   assert(NumDimsS >= Dim + 1);
   OnlyDimS = OnlyDimS.project_out(isl::dim::set, Dim + 1, NumDimsS - Dim - 1);
 
   // Create artificial parametric upper bounds for dimensions smaller than Dim
   // as we are not interested in them.
if (OldDepth == NewDepth) {
     auto &R = scop->getRegion();
     (void)R;
     assert(NewL->getParentLoop() == OldL ||
            ((!OldL || !R.contains(OldL)) && R.contains(NewL)));
     Dom = Dom.add_dims(isl::dim::set, 1);
   } else {
     assert(OldDepth > NewDepth);
     int Diff = OldDepth - NewDepth;
-    int NumDim = Dom.tuple_dim();
+    int NumDim = Dom.tuple_dim().release();
     assert(NumDim >= Diff);
     Dom = Dom.project_out(isl::dim::set, NumDim - Diff, Diff);
   }
 
   return Dom;
 }
 
 /// Compute the isl representation for the SCEV @p E in this BB.
bool ScopBuilder::buildConditionSets(
   if (!TI)
     ConsequenceCondSet = isl_set_params(ConsequenceCondSet);
   assert(ConsequenceCondSet);
   ConsequenceCondSet = isl_set_coalesce(
       isl_set_intersect(ConsequenceCondSet, isl_set_copy(Domain)));
 
   isl_set *AlternativeCondSet = nullptr;
   bool TooComplex =
-      isl_set_n_basic_set(ConsequenceCondSet) >= MaxDisjunctsInDomain;
+      isl_set_n_basic_set(ConsequenceCondSet) >= (isl_size)MaxDisjunctsInDomain;
 
   if (!TooComplex) {
     AlternativeCondSet = isl_set_subtract(isl_set_copy(Domain),
                                           isl_set_copy(ConsequenceCondSet));
-    TooComplex =
-        isl_set_n_basic_set(AlternativeCondSet) >= MaxDisjunctsInDomain;
+    TooComplex = isl_set_n_basic_set(AlternativeCondSet) >=
+                 (isl_size)MaxDisjunctsInDomain;
   }
 
   if (TooComplex) {
     scop->invalidate(COMPLEXITY, TI ? TI->getDebugLoc() : DebugLoc(),
                      TI ? TI->getParent() : nullptr /* BasicBlock */);
     isl_set_free(AlternativeCondSet);
     isl_set_free(ConsequenceCondSet);
     return false;
bool ScopBuilder::buildDomains(
   bool IsOnlyNonAffineRegion = scop->isNonAffineSubRegion(R);
   auto *EntryBB = R->getEntry();
   auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
   int LD = scop->getRelativeLoopDepth(L);
   auto *S =
       isl_set_universe(isl_space_set_alloc(scop->getIslCtx().get(), 0, LD + 1));
 
   InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S)));
-  isl::noexceptions::set Domain = isl::manage(S);
+  isl::set Domain = isl::manage(S);
   scop->setDomain(EntryBB, Domain);
 
   if (IsOnlyNonAffineRegion)
     return !containsErrorBlock(R->getNode(), *R, LI, DT);
 
   if (!buildDomainsWithBranchConstraints(R, InvalidDomainMap))
     return false;
 
for (auto *RN : RTraversal) {
 
     if (isa<UnreachableInst>(TI))
       continue;
 
     if (!scop->isDomainDefined(BB))
       continue;
     isl::set Domain = scop->getDomainConditions(BB);
 
-    scop->updateMaxLoopDepth(Domain.tuple_dim());
+    isl::size DomainDim = Domain.tuple_dim();
+    IslAssertNoError(DomainDim);
+    scop->updateMaxLoopDepth(static_cast<unsigned>(DomainDim));
 
     auto *BBLoop = getRegionNodeLoop(RN, LI);
     // Propagate the domain from BB directly to blocks that have a superset
     // domain, at the moment only region exit nodes of regions that start in BB.
     propagateDomainConstraintsToRegionExit(BB, BBLoop, FinishedExitBlocks,
                                            InvalidDomainMap);
 
     // If all successors of BB have been set a domain through the propagation
for (unsigned u = 0, e = ConditionSets.size(); u < e; u++) {
       } else {
         // Initialize the invalid domain.
         InvalidDomainMap[SuccBB] = CondSet.empty(CondSet.get_space());
         SuccDomain = CondSet;
       }
 
       SuccDomain = SuccDomain.detect_equalities();
 
+      isl::size SuccDomainSize = SuccDomain.n_basic_set();
+      IslAssertNoError(SuccDomainSize);
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will clean up and bail.
-      if (SuccDomain.n_basic_set() < MaxDisjunctsInDomain)
+      if (static_cast<unsigned>(SuccDomainSize) < MaxDisjunctsInDomain)
         continue;
 
       scop->invalidate(COMPLEXITY, DebugLoc());
       while (++u < ConditionSets.size())
         isl_set_free(ConditionSets[u]);
       return false;
     }
   }
for (unsigned u = 0; u < NumSuccs; u++) {
           adjustDomainDimensions(InvalidDomain, BBLoop, SuccBBLoop);
 
       isl::set SuccInvalidDomain = InvalidDomainMap[SuccBB];
       SuccInvalidDomain = SuccInvalidDomain.unite(AdjustedInvalidDomain);
       SuccInvalidDomain = SuccInvalidDomain.coalesce();
 
       InvalidDomainMap[SuccBB] = SuccInvalidDomain;
 
+      isl::size SuccInvalidDomainSize = SuccInvalidDomain.n_basic_set();
+      IslAssertNoError(SuccInvalidDomainSize);
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will bail.
-      if (SuccInvalidDomain.n_basic_set() < MaxDisjunctsInDomain)
+      if (static_cast<unsigned>(SuccInvalidDomainSize) < MaxDisjunctsInDomain)
         continue;
 
       InvalidDomainMap.erase(BB);
       scop->invalidate(COMPLEXITY, TI->getDebugLoc(), TI->getParent());
       return false;
     }
 
     InvalidDomainMap[BB] = InvalidDomain;

 static isl::multi_union_pw_aff mapToDimension(isl::union_set USet, int N) {
   assert(N >= 0);
   assert(!USet.is_null());
   assert(!USet.is_empty());
 
   auto Result = isl::union_pw_multi_aff::empty(USet.get_space());
 
   for (isl::set S : USet.get_set_list()) {
-    int Dim = S.tuple_dim();
+    int Dim = S.tuple_dim().release();
+    assert(Dim >= N);
     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::multi_union_pw_aff(isl::union_pw_multi_aff(Result));
if (!Schedule.is_null()) {
         /// boxed loop. It still needs to pass-through loop with user-defined
         /// metadata.
         scop->markDisableHeuristics();
       }
 
       // It is easier to insert the marks here that do it retroactively.
       isl::id IslLoopId = createIslLoopAttr(scop->getIslCtx(), L);
       if (!IslLoopId.is_null())
-        Schedule = Schedule.get_root()
-                       .get_child(0)
-                       .insert_mark(IslLoopId)
-                       .get_schedule();
+        Schedule =
+            Schedule.get_root().child(0).insert_mark(IslLoopId).get_schedule();
 
       LoopData->Schedule = combineInSequence(LoopData->Schedule, Schedule);
     }
 
     LoopData->NumBlocksProcessed += NumBlocksProcessed;
   }
   // Now pop all loops processed up there from the LoopStack
   LoopStack.erase(LoopStack.begin() + Dimension, LoopStack.end());
for (auto Array : scop->arrays()) {
 
     if (!Accessed.contains(Space))
       continue;
 
     isl::set Elements = Accessed.extract_set(Space);
     isl::map Transform = isl::map::universe(Array->getSpace().map_from_set());
 
     std::vector<int> Int;
-    int Dims = Elements.tuple_dim();
-    for (int i = 0; i < Dims; i++) {
+    isl::size Size = Elements.tuple_dim();
+    IslAssertNoError(Size);
+    unsigned Dims = static_cast<unsigned>(Size);
+    for (unsigned i = 0; i < Dims; i++) {
       isl::set DimOnly = isl::set(Elements).project_out(isl::dim::set, 0, i);
       DimOnly = DimOnly.project_out(isl::dim::set, 1, Dims - i - 1);
       DimOnly = DimOnly.lower_bound_si(isl::dim::set, 0, 0);
 
       isl::basic_set DimHull = DimOnly.affine_hull();
 
       if (i == Dims - 1) {
         Int.push_back(1);
         Transform = Transform.equate(isl::dim::in, i, isl::dim::out, i);
         continue;
       }
 
-      if (DimHull.dim(isl::dim::div) == 1) {
+      if (DimHull.dim(isl::dim::div).release() == 1) {
         isl::aff Diff = DimHull.get_div(0);
         isl::val Val = Diff.get_denominator_val();
 
         int ValInt = 1;
         if (Val.is_int()) {
           auto ValAPInt = APIntFromVal(Val);
           if (ValAPInt.isSignedIntN(32))
             ValInt = ValAPInt.getSExtValue();

 ///
 /// @param AccessRange The range to check for complexity.
 ///
 /// @returns True if the access range is too complex.
 static bool isAccessRangeTooComplex(isl::set AccessRange) {
   int NumTotalDims = 0;
 
   for (isl::basic_set BSet : AccessRange.get_basic_set_list()) {
-    NumTotalDims += BSet.dim(isl::dim::div);
-    NumTotalDims += BSet.dim(isl::dim::set);
+    isl::size Dim = BSet.dim(isl::dim::div);
+    IslAssertNoError(Dim);
+    NumTotalDims += static_cast<unsigned>(Dim);
+
+    Dim = BSet.dim(isl::dim::set);
+    IslAssertNoError(Dim);
+    NumTotalDims += static_cast<unsigned>(Dim);
   }
 
   if (NumTotalDims > MaxDimensionsInAccessRange)
     return true;
 
   return false;
 }
 
if (Space.dim(isl::dim::param) != UserContext.dim(isl::dim::param)) {
     std::string SpaceStr = stringFromIslObj(Space, "null");
     errs() << "Error: the context provided in -polly-context has not the same "
            << "number of dimensions than the computed context. Due to this "
            << "mismatch, the -polly-context option is ignored. Please provide "
            << "the context in the parameter space: " << SpaceStr << ".\n";
     return;
   }
 
-  for (auto i : seq<isl_size>(0, Space.dim(isl::dim::param))) {
+  for (auto i : rangeIslSize(0, Space.dim(isl::dim::param))) {
     std::string NameContext =
         scop->getContext().get_dim_name(isl::dim::param, i);
     std::string NameUserContext = UserContext.get_dim_name(isl::dim::param, i);
 
     if (NameContext != NameUserContext) {
       std::string SpaceStr = stringFromIslObj(Space, "null");
       errs() << "Error: the name of dimension " << i
              << " provided in -polly-context "
isl::set ScopBuilder::getNonHoistableCtx(MemoryAccess *Access,
   isl::union_map Written = Writes.intersect_range(SafeToLoad);
   isl::set WrittenCtx = Written.params();
   bool IsWritten = !WrittenCtx.is_empty();
 
   if (!IsWritten)
     return WrittenCtx;
 
   WrittenCtx = WrittenCtx.remove_divs();
-  bool TooComplex = WrittenCtx.n_basic_set() >= MaxDisjunctsInDomain;
+  isl::size Disjuncts = WrittenCtx.n_basic_set();
+  if (Disjuncts.is_error())
+    return {};
+  bool TooComplex = static_cast<unsigned>(Disjuncts) >= MaxDisjunctsInDomain;
   if (TooComplex || !isRequiredInvariantLoad(LI))
     return {};
 
   scop->addAssumption(INVARIANTLOAD, WrittenCtx, LI->getDebugLoc(),
                       AS_RESTRICTION, LI->getParent());
   return WrittenCtx;
 }
 
void ScopBuilder::addInvariantLoads(ScopStmt &Stmt,
   isl::set StmtInvalidCtx = Stmt.getInvalidContext();
   bool StmtInvalidCtxIsEmpty = StmtInvalidCtx.is_empty();
 
   // 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 (DomainCtx.n_basic_set() >= MaxDisjunctsInDomain) {
+  isl::size DomainCtxSize = DomainCtx.n_basic_set();
+  if (DomainCtxSize.is_error() ||
+      static_cast<unsigned>(DomainCtxSize) >= MaxDisjunctsInDomain) {
     auto *AccInst = InvMAs.front().MA->getAccessInstruction();
     scop->invalidate(COMPLEXITY, AccInst->getDebugLoc(), AccInst->getParent());
     return;
   }
 
   // Project out all parameters that relate to loads in the statement. Otherwise
   // we could have cyclic dependences on the constraints under which the
   // hoisted loads are executed and we could not determine an order in which to
static bool buildMinMaxAccess(isl::set Set,
   isl::pw_multi_aff MinPMA, MaxPMA;
   isl::pw_aff LastDimAff;
   isl::aff OneAff;
   unsigned Pos;
 
   Set = Set.remove_divs();
   polly::simplify(Set);
 
-  if (Set.n_basic_set() > RunTimeChecksMaxAccessDisjuncts)
+  isl::size SetSize = Set.n_basic_set();
+  if (SetSize.is_error() ||
+      static_cast<unsigned>(SetSize) > RunTimeChecksMaxAccessDisjuncts)
     Set = Set.simple_hull();
 
   // Restrict the number of parameters involved in the access as the lexmin/
   // lexmax computation will take too long if this number is high.
   //
   // Experiments with a simple test case using an i7 4800MQ:
   //
   //  #Parameters involved | Time (in sec)
static bool buildMinMaxAccess(isl::set Set,
   }
 
   MinPMA = Set.lexmin_pw_multi_aff();
   MaxPMA = Set.lexmax_pw_multi_aff();
 
   MinPMA = MinPMA.coalesce();
   MaxPMA = MaxPMA.coalesce();
 
+  if (MaxPMA.is_null())
+    return false;
+
   // Adjust the last dimension of the maximal access by one as we want to
   // enclose the accessed memory region by MinPMA and MaxPMA. The pointer
   // we test during code generation might now point after the end of the
   // allocated array but we will never dereference it anyway.
-  assert((MaxPMA.is_null() || MaxPMA.dim(isl::dim::out)) &&
+  isl::size Dims = MaxPMA.dim(isl::dim::out);
+  assert((!Dims.is_error() && static_cast<unsigned>(Dims) > 0) &&
          "Assumed at least one output dimension");
+  IslAssertNoError(Dims);
 
-  Pos = MaxPMA.dim(isl::dim::out) - 1;
-  LastDimAff = MaxPMA.get_pw_aff(Pos);
+  Pos = static_cast<unsigned>(Dims) - 1;
+  LastDimAff = MaxPMA.at(Pos);
   OneAff = isl::aff(isl::local_space(LastDimAff.get_domain_space()));
   OneAff = OneAff.add_constant_si(1);
   LastDimAff = LastDimAff.add(OneAff);
   MaxPMA = MaxPMA.set_pw_aff(Pos, LastDimAff);
 
   if (MinPMA.is_null() || MaxPMA.is_null())
     return false;
 
if (LimitReached)
       break;
   }
 
   return !LimitReached;
 }
 
 static isl::set getAccessDomain(MemoryAccess *MA) {
   isl::set Domain = MA->getStatement()->getDomain();
-  Domain = Domain.project_out(isl::dim::set, 0, Domain.tuple_dim());
+  isl::size Dim = Domain.tuple_dim();
+  IslAssertNoError(Dim);
+  Domain = Domain.project_out(isl::dim::set, 0, static_cast<unsigned>(Dim));
   return Domain.reset_tuple_id();
 }
 
 bool ScopBuilder::buildAliasChecks() {
   if (!PollyUseRuntimeAliasChecks)
     return true;
 
   if (buildAliasGroups()) {

polly/lib/Analysis/ScopInfo.cpp

STATISTIC(
     "Number of scalar value writes nested in affine loops after ScopInfo");
 STATISTIC(NumPHIWrites, "Number of scalar phi writes after ScopInfo");
 STATISTIC(NumPHIWritesInLoops,
           "Number of scalar phi writes nested in affine loops after ScopInfo");
 STATISTIC(NumSingletonWrites, "Number of singleton writes after ScopInfo");
 STATISTIC(NumSingletonWritesInLoops,
           "Number of singleton writes nested in affine loops after ScopInfo");
 
-int const polly::MaxDisjunctsInDomain = 20;
+unsigned const polly::MaxDisjunctsInDomain = 20;
 
 // The number of disjunct in the context after which we stop to add more
 // disjuncts. This parameter is there to avoid exponential growth in the
 // number of disjunct when adding non-convex sets to the context.
 static int const MaxDisjunctsInContext = 4;
 
 // Be a bit more generous for the defined behavior context which is used less
 // often.
static isl::set addRangeBoundsToSet(isl::set S, const ConstantRange &Range,
   V = valFromAPInt(Ctx.get(), Range.getSignedMin(), true);
   S = S.lower_bound_val(type, dim, V);
   V = valFromAPInt(Ctx.get(), Range.getSignedMax(), true);
   S = S.upper_bound_val(type, dim, V);
 
   if (Range.isFullSet())
     return S;
 
-  if (S.n_basic_set() > MaxDisjunctsInContext)
+  isl::size Size = S.n_basic_set();
+  IslAssertNoError(Size);
+  if (static_cast<unsigned>(Size) > MaxDisjunctsInContext)
     return S;
 
   // In case of signed wrapping, we can refine the set of valid values by
   // excluding the part not covered by the wrapping range.
   if (Range.isSignWrappedSet()) {
     V = valFromAPInt(Ctx.get(), Range.getLower(), true);
     isl::set SLB = S.lower_bound_val(type, dim, V);
 

 }
 
 void MemoryAccess::updateDimensionality() {
   auto *SAI = getScopArrayInfo();
   isl::space ArraySpace = SAI->getSpace();
   isl::space AccessSpace = AccessRelation.get_space().range();
   isl::ctx Ctx = ArraySpace.ctx();
 
-  auto DimsArray = ArraySpace.dim(isl::dim::set);
-  auto DimsAccess = AccessSpace.dim(isl::dim::set);
+  isl::size Size = ArraySpace.dim(isl::dim::set);
+  IslAssertNoError(Size);
+  auto DimsArray = static_cast<unsigned>(Size);
+  Size = AccessSpace.dim(isl::dim::set);
+  IslAssertNoError(Size);
+  auto DimsAccess = static_cast<unsigned>(Size);
+  assert(DimsArray >= DimsAccess);
   auto DimsMissing = DimsArray - DimsAccess;
 
   auto *BB = getStatement()->getEntryBlock();
   auto &DL = BB->getModule()->getDataLayout();
   unsigned ArrayElemSize = SAI->getElemSizeInBytes();
   unsigned ElemBytes = DL.getTypeAllocSize(getElementType());
 
   isl::map Map = isl::map::from_domain_and_range(

 // parameters that may cause statement instances to be executed that may
 // possibly yield out of bound memory accesses. The complement of these
 // constraints is the set of constraints that needs to be assumed to ensure such
 // statement instances are never executed.
 isl::set MemoryAccess::assumeNoOutOfBound() {
   auto *SAI = getScopArrayInfo();
   isl::space Space = getOriginalAccessRelationSpace().range();
   isl::set Outside = isl::set::empty(Space);
-  for (int i = 1, Size = Space.dim(isl::dim::set); i < Size; ++i) {
+  for (unsigned i : rangeIslSize(1, Space.dim(isl::dim::set))) {
     isl::local_space LS(Space);
     isl::pw_aff Var = isl::pw_aff::var_on_domain(LS, isl::dim::set, i);
     isl::pw_aff Zero = isl::pw_aff(LS);
 
     isl::set DimOutside = Var.lt_set(Zero);
     isl::pw_aff SizeE = SAI->getDimensionSizePw(i);
-    SizeE = SizeE.add_dims(isl::dim::in, Space.dim(isl::dim::set));
+    SizeE = SizeE.add_dims(isl::dim::in, Space.dim(isl::dim::set).release());
     SizeE = SizeE.set_tuple_id(isl::dim::in, Space.get_tuple_id(isl::dim::set));
     DimOutside = DimOutside.unite(SizeE.le_set(Var));
 
     Outside = Outside.unite(DimOutside);
   }
 
   Outside = Outside.apply(getAccessRelation().reverse());
   Outside = Outside.intersect(Statement->getDomain());
void MemoryAccess::foldAccessRelation() {
   NewAccessRelation = NewAccessRelation.set_tuple_id(
       isl::dim::in, Space.get_tuple_id(isl::dim::set));
   NewAccessRelation = NewAccessRelation.set_tuple_id(isl::dim::out, BaseAddrId);
   NewAccessRelation = NewAccessRelation.gist_domain(Statement->getDomain());
 
   // Access dimension folding might in certain cases increase the number of
   // disjuncts in the memory access, which can possibly complicate the generated
   // run-time checks and can lead to costly compilation.
-  if (!PollyPreciseFoldAccesses &&
-      NewAccessRelation.n_basic_map() > AccessRelation.n_basic_map()) {
+  if (!PollyPreciseFoldAccesses && NewAccessRelation.n_basic_map().release() >
+                                       AccessRelation.n_basic_map().release()) {
   } else {
     AccessRelation = NewAccessRelation;
   }
 }
 
 void MemoryAccess::buildAccessRelation(const ScopArrayInfo *SAI) {
   assert(AccessRelation.is_null() && "AccessRelation already built");
 

 //   getEqualAndLarger(set[i0, i1, ..., iX]):
 //
 //   set[i0, i1, ..., iX] -> set[o0, o1, ..., oX]
 //     : i0 = o0, i1 = o1, ..., i(X-1) = o(X-1), iX < oX
 //
 static isl::map getEqualAndLarger(isl::space SetDomain) {
   isl::space Space = SetDomain.map_from_set();
   isl::map Map = isl::map::universe(Space);
-  unsigned lastDimension = Map.domain_tuple_dim() - 1;
+  isl::size DomainDim = Map.domain_tuple_dim();
+  IslAssertNoError(DomainDim);
+  assert(static_cast<unsigned>(DomainDim) > 0);
+  unsigned lastDimension = static_cast<unsigned>(DomainDim) - 1;
 
   // Set all but the last dimension to be equal for the input and output
   //
   //   input[i0, i1, ..., iX] -> output[o0, o1, ..., oX]
   //     : i0 = o0, i1 = o1, ..., i(X-1) = o(X-1)
   for (unsigned i = 0; i < lastDimension; ++i)
     Map = Map.equate(isl::dim::in, i, isl::dim::out, i);
 

 }
 
 bool MemoryAccess::isStrideX(isl::map Schedule, int StrideWidth) const {
   isl::set Stride, StrideX;
   bool IsStrideX;
 
   Stride = getStride(Schedule);
   StrideX = isl::set::universe(Stride.get_space());
-  for (auto i : seq<isl_size>(0, StrideX.tuple_dim() - 1))
+  isl::size Dim = StrideX.tuple_dim();
+  IslAssertNoError(Dim);
+  unsigned UDim = static_cast<unsigned>(Dim);
+  assert(UDim > 0);
+  for (auto i : seq<unsigned>(0, UDim - 1))
     StrideX = StrideX.fix_si(isl::dim::set, i, 0);
-  StrideX = StrideX.fix_si(isl::dim::set, StrideX.tuple_dim() - 1, StrideWidth);
+  StrideX = StrideX.fix_si(isl::dim::set, UDim - 1, StrideWidth);
   IsStrideX = Stride.is_subset(StrideX);
 
   return IsStrideX;
 }
 
 bool MemoryAccess::isStrideZero(isl::map Schedule) const {
   return isStrideX(Schedule, 0);
 }
if (SAI->isArrayKind() && SAI->getBasePtrOriginSAI()) {
     assert(EqClass &&
            "Access functions to indirect arrays must have an invariant and "
            "hoisted base pointer");
   }
 
   // Check whether access dimensions correspond to number of dimensions of the
   // accesses array.
   isl_size Dims = SAI->getNumberOfDimensions();
-  assert(NewAccessSpace.dim(isl::dim::set) == Dims &&
+  assert(NewAccessSpace.dim(isl::dim::set).release() == Dims &&
          "Access dims must match array dims");
 #endif
 
   NewAccess = NewAccess.gist_params(getStatement()->getParent()->getContext());
   NewAccess = NewAccess.gist_domain(getStatement()->getDomain());
   NewAccessRelation = NewAccess;
 }
 
void Scop::intersectDefinedBehavior(isl::set Set, AssumptionSign Sign) {
 
   if (Sign == AS_ASSUMPTION)
     DefinedBehaviorContext = DefinedBehaviorContext.intersect(Set);
   else
     DefinedBehaviorContext = DefinedBehaviorContext.subtract(Set);
 
   // Limit the complexity of the context. If complexity is exceeded, simplify
   // the set and check again.
-  if (DefinedBehaviorContext.n_basic_set() >
+  if (DefinedBehaviorContext.n_basic_set().release() >
       MaxDisjunktsInDefinedBehaviourContext) {
     simplify(DefinedBehaviorContext);
-    if (DefinedBehaviorContext.n_basic_set() >
+    if (DefinedBehaviorContext.n_basic_set().release() >
         MaxDisjunktsInDefinedBehaviourContext)
       DefinedBehaviorContext = {};
   }
 }
 
 void Scop::invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB) {
   LLVM_DEBUG(dbgs() << "Invalidate SCoP because of reason " << Kind << "\n");
   addAssumption(Kind, isl::set::empty(getParamSpace()), Loc, AS_ASSUMPTION, BB);

polly/lib/CodeGen/BlockGenerators.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "polly/CodeGen/BlockGenerators.h"
 #include "polly/CodeGen/IslExprBuilder.h"
 #include "polly/CodeGen/RuntimeDebugBuilder.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
+#include "polly/Support/ISLTools.h"
 #include "polly/Support/ScopHelper.h"
 #include "polly/Support/VirtualInstruction.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "isl/ast.h"
void BlockGenerator::generateBeginStmtTrace(ScopStmt &Stmt, LoopToScevMapT &LTS,
   SmallVector<llvm::Value *, 8> Values;
 
   // Print the name of the statement.
   // TODO: Indent by the depth of the statement instance in the schedule tree.
   Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, BaseName));
   Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, "("));
 
   // Add the coordinate of the statement instance.
-  int DomDims = ScheduleMultiPwAff.dim(isl::dim::out);
-  for (int i = 0; i < DomDims; i += 1) {
+  for (unsigned i : rangeIslSize(0, ScheduleMultiPwAff.dim(isl::dim::out))) {
     if (i > 0)
       Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, ","));
 
-    isl::ast_expr IsInSet =
-        RestrictedBuild.expr_from(ScheduleMultiPwAff.get_pw_aff(i));
+    isl::ast_expr IsInSet = RestrictedBuild.expr_from(ScheduleMultiPwAff.at(i));
     Values.push_back(ExprBuilder->create(IsInSet.copy()));
   }
 
   if (TraceScalars) {
     Values.push_back(RuntimeDebugBuilder::getPrintableString(Builder, ")"));
     DenseSet<Instruction *> Encountered;
 
     // Add the value of each scalar (and the result of PHIs) used in the

polly/lib/CodeGen/IslAst.cpp

IslAstInfo IslAstAnalysis::run(Scop &S, ScopAnalysisManager &SAM,
 
   return std::move(*runIslAst(S, GetDeps).release());
 }
 
 static __isl_give isl_printer *cbPrintUser(__isl_take isl_printer *P,
                                            __isl_take isl_ast_print_options *O,
                                            __isl_keep isl_ast_node *Node,
                                            void *User) {
-  isl::ast_node AstNode = isl::manage_copy(Node);
-  isl::ast_expr NodeExpr = AstNode.user_get_expr();
+  isl::ast_node_user AstNode = isl::manage_copy(Node).as<isl::ast_node_user>();
+  isl::ast_expr NodeExpr = AstNode.expr();
   isl::ast_expr CallExpr = NodeExpr.get_op_arg(0);
   isl::id CallExprId = CallExpr.get_id();
   ScopStmt *AccessStmt = (ScopStmt *)CallExprId.get_user();
 
   P = isl_printer_start_line(P);
   P = isl_printer_print_str(P, AccessStmt->getBaseName());
   P = isl_printer_print_str(P, "(");
   P = isl_printer_end_line(P);

polly/lib/CodeGen/IslNodeBuilder.cpp

static cl::opt<int> PollyTargetFirstLevelCacheLineSize(
     cl::Hidden, cl::init(64), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<OpenMPBackend> PollyOmpBackend(
     "polly-omp-backend", cl::desc("Choose the OpenMP library to use:"),
     cl::values(clEnumValN(OpenMPBackend::GNU, "GNU", "GNU OpenMP"),
                clEnumValN(OpenMPBackend::LLVM, "LLVM", "LLVM OpenMP")),
     cl::Hidden, cl::init(OpenMPBackend::GNU), cl::cat(PollyCategory));
 
-isl::ast_expr IslNodeBuilder::getUpperBound(isl::ast_node For,
+isl::ast_expr IslNodeBuilder::getUpperBound(isl::ast_node_for For,
                                             ICmpInst::Predicate &Predicate) {
-  isl::ast_expr Cond = For.for_get_cond();
-  isl::ast_expr Iterator = For.for_get_iterator();
+  isl::ast_expr Cond = For.cond();
+  isl::ast_expr Iterator = For.iterator();
   assert(isl_ast_expr_get_type(Cond.get()) == isl_ast_expr_op &&
          "conditional expression is not an atomic upper bound");
 
   isl_ast_op_type OpType = isl_ast_expr_get_op_type(Cond.get());
 
   switch (OpType) {
   case isl_ast_op_le:
     Predicate = ICmpInst::ICMP_SLE;
static bool checkIslAstExprInt(__isl_take isl_ast_expr *Expr,
   if (Predicate(ExprVal) != isl_bool_true) {
     isl_val_free(ExprVal);
     return false;
   }
   isl_val_free(ExprVal);
   return true;
 }
 
-int IslNodeBuilder::getNumberOfIterations(isl::ast_node For) {
+int IslNodeBuilder::getNumberOfIterations(isl::ast_node_for For) {
   assert(isl_ast_node_get_type(For.get()) == isl_ast_node_for);
-  isl::ast_node Body = For.for_get_body();
+  isl::ast_node Body = For.body();
 
   // First, check if we can actually handle this code.
   switch (isl_ast_node_get_type(Body.get())) {
   case isl_ast_node_user:
     break;
   case isl_ast_node_block: {
-    isl::ast_node_list List = Body.block_get_children();
+    isl::ast_node_block BodyBlock = Body.as<isl::ast_node_block>();
+    isl::ast_node_list List = BodyBlock.children();
     for (isl::ast_node Node : List) {
       isl_ast_node_type NodeType = isl_ast_node_get_type(Node.get());
       if (NodeType != isl_ast_node_user)
         return -1;
     }
     break;
   }
   default:
     return -1;
   }
 
-  isl::ast_expr Init = For.for_get_init();
+  isl::ast_expr Init = For.init();
   if (!checkIslAstExprInt(Init.release(), isl_val_is_zero))
     return -1;
-  isl::ast_expr Inc = For.for_get_inc();
+  isl::ast_expr Inc = For.inc();
   if (!checkIslAstExprInt(Inc.release(), isl_val_is_one))
     return -1;
   CmpInst::Predicate Predicate;
   isl::ast_expr UB = getUpperBound(For, Predicate);
   if (isl_ast_expr_get_type(UB.get()) != isl_ast_expr_int)
     return -1;
   isl::val UpVal = UB.get_val();
   int NumberIterations = UpVal.get_num_si();
void IslNodeBuilder::createMark(__isl_take isl_ast_node *Node) {
   auto *Id = isl_ast_node_mark_get_id(Node);
   auto Child = isl_ast_node_mark_get_node(Node);
   isl_ast_node_free(Node);
   // If a child node of a 'SIMD mark' is a loop that has a single iteration,
   // it will be optimized away and we should skip it.
   if (strcmp(isl_id_get_name(Id), "SIMD") == 0 &&
       isl_ast_node_get_type(Child) == isl_ast_node_for) {
     bool Vector = PollyVectorizerChoice == VECTORIZER_POLLY;
-    int VectorWidth = getNumberOfIterations(isl::manage_copy(Child));
+    int VectorWidth =
+        getNumberOfIterations(isl::manage_copy(Child).as<isl::ast_node_for>());
     if (Vector && 1 < VectorWidth && VectorWidth <= 16)
       createForVector(Child, VectorWidth);
     else
-      createForSequential(isl::manage(Child), true);
+      createForSequential(isl::manage(Child).as<isl::ast_node_for>(), true);
     isl_id_free(Id);
     return;
   }
   if (strcmp(isl_id_get_name(Id), "Inter iteration alias-free") == 0) {
     auto *BasePtr = static_cast<Value *>(isl_id_get_user(Id));
     Annotator.addInterIterationAliasFreeBasePtr(BasePtr);
   }
 

 /// Restore the initial ordering of dimensions of the band node
 ///
 /// In case the band node represents all the dimensions of the iteration
 /// domain, recreate the band node to restore the initial ordering of the
 /// dimensions.
 ///
 /// @param Node The band node to be modified.
 /// @return The modified schedule node.
-static bool IsLoopVectorizerDisabled(isl::ast_node Node) {
+static bool IsLoopVectorizerDisabled(isl::ast_node_for Node) {
   assert(isl_ast_node_get_type(Node.get()) == isl_ast_node_for);
-  auto Body = Node.for_get_body();
+  isl::ast_node Body = Node.body();
   if (isl_ast_node_get_type(Body.get()) != isl_ast_node_mark)
     return false;
-  auto Id = Body.mark_get_id();
+
+  isl::ast_node_mark BodyMark = Body.as<isl::ast_node_mark>();
+  auto Id = BodyMark.id();
   if (strcmp(Id.get_name().c_str(), "Loop Vectorizer Disabled") == 0)
     return true;
   return false;
 }
 
-void IslNodeBuilder::createForSequential(isl::ast_node For, bool MarkParallel) {
+void IslNodeBuilder::createForSequential(isl::ast_node_for For,
+                                         bool MarkParallel) {
   Value *ValueLB, *ValueUB, *ValueInc;
   Type *MaxType;
   BasicBlock *ExitBlock;
   Value *IV;
   CmpInst::Predicate Predicate;
 
   bool LoopVectorizerDisabled = IsLoopVectorizerDisabled(For);
 
-  isl::ast_node Body = For.for_get_body();
+  isl::ast_node Body = For.body();
 
   // isl_ast_node_for_is_degenerate(For)
   //
   // TODO: For degenerated loops we could generate a plain assignment.
   //       However, for now we just reuse the logic for normal loops, which will
   //       create a loop with a single iteration.
 
-  isl::ast_expr Init = For.for_get_init();
-  isl::ast_expr Inc = For.for_get_inc();
-  isl::ast_expr Iterator = For.for_get_iterator();
+  isl::ast_expr Init = For.init();
+  isl::ast_expr Inc = For.inc();
+  isl::ast_expr Iterator = For.iterator();
   isl::id IteratorID = Iterator.get_id();
   isl::ast_expr UB = getUpperBound(For, Predicate);
 
   ValueLB = ExprBuilder.create(Init.release());
   ValueUB = ExprBuilder.create(UB.release());
   ValueInc = ExprBuilder.create(Inc.release());
 
   MaxType = ExprBuilder.getType(Iterator.get());
void IslNodeBuilder::createForParallel(__isl_take isl_ast_node *For) {
   ParBB->setName("polly.parallel.for");
   Builder.SetInsertPoint(&ParBB->front());
 
   Body = isl_ast_node_for_get_body(For);
   Init = isl_ast_node_for_get_init(For);
   Inc = isl_ast_node_for_get_inc(For);
   Iterator = isl_ast_node_for_get_iterator(For);
   IteratorID = isl_ast_expr_get_id(Iterator);
-  UB = getUpperBound(isl::manage_copy(For), Predicate).release();
+  UB = getUpperBound(isl::manage_copy(For).as<isl::ast_node_for>(), Predicate)
+           .release();
 
   ValueLB = ExprBuilder.create(Init);
   ValueUB = ExprBuilder.create(UB);
   ValueInc = ExprBuilder.create(Inc);
 
   // OpenMP always uses SLE. In case the isl generated AST uses a SLT
   // expression, we need to adjust the loop bound by one.
   if (Predicate == CmpInst::ICMP_SLT)
return isl_ast_node_foreach_descendant_top_down(
              nullptr) == isl_stat_error;
 }
 
 void IslNodeBuilder::createFor(__isl_take isl_ast_node *For) {
   bool Vector = PollyVectorizerChoice == VECTORIZER_POLLY;
 
   if (Vector && IslAstInfo::isInnermostParallel(isl::manage_copy(For)) &&
       !IslAstInfo::isReductionParallel(isl::manage_copy(For))) {
-    int VectorWidth = getNumberOfIterations(isl::manage_copy(For));
+    int VectorWidth =
+        getNumberOfIterations(isl::manage_copy(For).as<isl::ast_node_for>());
     if (1 < VectorWidth && VectorWidth <= 16 && !hasPartialAccesses(For)) {
       createForVector(For, VectorWidth);
       return;
     }
   }
 
   if (IslAstInfo::isExecutedInParallel(isl::manage_copy(For))) {
     createForParallel(For);
     return;
   }
   bool Parallel = (IslAstInfo::isParallel(isl::manage_copy(For)) &&
                    !IslAstInfo::isReductionParallel(isl::manage_copy(For)));
-  createForSequential(isl::manage(For), Parallel);
+  createForSequential(isl::manage(For).as<isl::ast_node_for>(), Parallel);
 }
 
 void IslNodeBuilder::createIf(__isl_take isl_ast_node *If) {
   isl_ast_expr *Cond = isl_ast_node_if_get_cond(If);
 
   Function *F = Builder.GetInsertBlock()->getParent();
   LLVMContext &Context = F->getContext();
 

polly/lib/CodeGen/PPCGCodeGeneration.cpp

 #include "polly/CodeGen/IslNodeBuilder.h"
 #include "polly/CodeGen/PerfMonitor.h"
 #include "polly/CodeGen/Utils.h"
 #include "polly/DependenceInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopDetection.h"
 #include "polly/ScopInfo.h"
+#include "polly/Support/ISLTools.h"
 #include "polly/Support/SCEVValidator.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/IntrinsicsNVPTX.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/InitializePasses.h"

 
 Value *GPUNodeBuilder::getArraySize(gpu_array_info *Array) {
   isl::ast_build Build = isl::ast_build::from_context(S.getContext());
   Value *ArraySize = ConstantInt::get(Builder.getInt64Ty(), Array->size);
 
   if (!gpu_array_is_scalar(Array)) {
     isl::multi_pw_aff ArrayBound = isl::manage_copy(Array->bound);
 
-    isl::pw_aff OffsetDimZero = ArrayBound.get_pw_aff(0);
+    isl::pw_aff OffsetDimZero = ArrayBound.at(0);
     isl::ast_expr Res = Build.expr_from(OffsetDimZero);
 
     for (unsigned int i = 1; i < Array->n_index; i++) {
-      isl::pw_aff Bound_I = ArrayBound.get_pw_aff(i);
+      isl::pw_aff Bound_I = ArrayBound.at(i);
       isl::ast_expr Expr = Build.expr_from(Bound_I);
       Res = Res.mul(Expr);
     }
 
     Value *NumElements = ExprBuilder.create(Res.release());
     if (NumElements->getType() != ArraySize->getType())
       NumElements = Builder.CreateSExt(NumElements, ArraySize->getType());
     ArraySize = Builder.CreateMul(ArraySize, NumElements);
   }
   return ArraySize;
 }
 
 Value *GPUNodeBuilder::getArrayOffset(gpu_array_info *Array) {
   if (gpu_array_is_scalar(Array))
     return nullptr;
 
   isl::ast_build Build = isl::ast_build::from_context(S.getContext());
 
   isl::set Min = isl::manage_copy(Array->extent).lexmin();
 
   isl::set ZeroSet = isl::set::universe(Min.get_space());
 
-  for (long i = 0, n = Min.tuple_dim(); i < n; i++)
+  for (long i = 0, n = Min.tuple_dim().release(); i < n; i++)
+    for (unsigned i : rangeIslSize(0, Min.tuple_dim()))
       ZeroSet = ZeroSet.fix_si(isl::dim::set, i, 0);
 
   if (Min.is_subset(ZeroSet)) {
     return nullptr;
   }
 
   isl::ast_expr Result = isl::ast_expr::from_val(isl::val(Min.ctx(), 0));
 
-  for (long i = 0, n = Min.tuple_dim(); i < n; i++) {
+  for (unsigned i : rangeIslSize(0, Min.tuple_dim())) {
     if (i > 0) {
       isl::pw_aff Bound_I =
           isl::manage(isl_multi_pw_aff_get_pw_aff(Array->bound, i - 1));
       isl::ast_expr BExpr = Build.expr_from(Bound_I);
       Result = Result.mul(BExpr);
     }
     isl::pw_aff DimMin = Min.dim_min(i);
     isl::ast_expr MExpr = Build.expr_from(DimMin);
case ppcg_kernel_sync:
     return;
   }
 
   isl_ast_expr_free(Expr);
   isl_ast_node_free(UserStmt);
 }
 
 void GPUNodeBuilder::createFor(__isl_take isl_ast_node *Node) {
-  createForSequential(isl::manage(Node), false);
+  createForSequential(isl::manage(Node).as<isl::ast_node_for>(), false);
 }
 
 void GPUNodeBuilder::createKernelCopy(ppcg_kernel_stmt *KernelStmt) {
   isl_ast_expr *LocalIndex = isl_ast_expr_copy(KernelStmt->u.c.local_index);
   LocalIndex = isl_ast_expr_address_of(LocalIndex);
   Value *LocalAddr = ExprBuilder.create(LocalIndex);
   isl_ast_expr *Index = isl_ast_expr_copy(KernelStmt->u.c.index);
   Index = isl_ast_expr_address_of(Index);

 }
 
 std::tuple<Value *, Value *> GPUNodeBuilder::getGridSizes(ppcg_kernel *Kernel) {
   std::vector<Value *> Sizes;
   isl::ast_build Context = isl::ast_build::from_context(S.getContext());
 
   isl::multi_pw_aff GridSizePwAffs = isl::manage_copy(Kernel->grid_size);
   for (long i = 0; i < Kernel->n_grid; i++) {
-    isl::pw_aff Size = GridSizePwAffs.get_pw_aff(i);
+    isl::pw_aff Size = GridSizePwAffs.at(i);
     isl::ast_expr GridSize = Context.expr_from(Size);
     Value *Res = ExprBuilder.create(GridSize.release());
     Res = Builder.CreateTrunc(Res, Builder.getInt32Ty());
     Sizes.push_back(Res);
   }
 
   for (long i = Kernel->n_grid; i < 3; i++)
     Sizes.push_back(ConstantInt::get(Builder.getInt32Ty(), 1));
isl::set getExtent(ScopArrayInfo *Array) {
 
     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);
     isl::pw_aff OuterMax = AccessSet.dim_max(0);
-    OuterMin = OuterMin.add_dims(isl::dim::in, Val.dim(isl::dim::in));
-    OuterMax = OuterMax.add_dims(isl::dim::in, Val.dim(isl::dim::in));
+    isl::size Dim = Val.dim(isl::dim::in);
+    IslAssertNoError(Dim);
+    unsigned UDim = static_cast<unsigned>(Dim);
+    OuterMin = OuterMin.add_dims(isl::dim::in, UDim);
+    OuterMax = OuterMax.add_dims(isl::dim::in, UDim);
     OuterMin = OuterMin.set_tuple_id(isl::dim::in, Array->getBasePtrId());
     OuterMax = OuterMax.set_tuple_id(isl::dim::in, Array->getBasePtrId());
 
     isl::set Extent = isl::set::universe(Array->getSpace());
 
     Extent = Extent.intersect(OuterMin.le_set(Val));
     Extent = Extent.intersect(OuterMax.ge_set(Val));
 
     for (unsigned i = 1; i < NumDims; ++i)
       Extent = Extent.lower_bound_si(isl::dim::set, i, 0);
 
     for (unsigned i = 0; i < NumDims; ++i) {
       isl::pw_aff PwAff = Array->getDimensionSizePw(i);
 
       // isl_pw_aff can be NULL for zero dimension. Only in the case of a
       // Fortran array will we have a legitimate dimension.
       if (PwAff.is_null()) {
         assert(i == 0 && "invalid dimension isl_pw_aff for nonzero dimension");
         continue;
       }
 
       isl::pw_aff Val = isl::aff::var_on_domain(
           isl::local_space(Array->getSpace()), isl::dim::set, i);
-      PwAff = PwAff.add_dims(isl::dim::in, Val.dim(isl::dim::in));
+      Dim = Val.dim(isl::dim::in);
+      IslAssertNoError(Dim);
+      PwAff = PwAff.add_dims(isl::dim::in, static_cast<unsigned>(Dim));
       PwAff = PwAff.set_tuple_id(isl::dim::in, Val.get_tuple_id(isl::dim::in));
       isl::set Set = PwAff.gt_set(Val);
       Extent = Set.intersect(Extent);
     }
 
     return Extent;
   }
 
void getAnalysisUsage(AnalysisUsage &AU) const override {
     // FIXME: We do not yet add regions for the newly generated code to the
     //        region tree.
   }
 };
 } // namespace
 
 char PPCGCodeGeneration::ID = 1;
 
 Pass *polly::createPPCGCodeGenerationPass(GPUArch Arch, GPURuntime Runtime) {
   PPCGCodeGeneration *generator = new PPCGCodeGeneration();
   generator->Runtime = Runtime;
   generator->Architecture = Arch;
   return generator;
 }
 
 INITIALIZE_PASS_BEGIN(PPCGCodeGeneration, "polly-codegen-ppcg",
                       "Polly - Apply PPCG translation to SCOP", false, false)
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_END(PPCGCodeGeneration, "polly-codegen-ppcg",
                     "Polly - Apply PPCG translation to SCOP", false, false)

polly/lib/Exchange/JSONExporter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "polly/JSONExporter.h"
 #include "polly/DependenceInfo.h"
 #include "polly/LinkAllPasses.h"
 #include "polly/Options.h"
 #include "polly/ScopInfo.h"
 #include "polly/ScopPass.h"
+#include "polly/Support/ISLTools.h"
 #include "polly/Support/ScopLocation.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
static bool importContext(Scop &S, const json::Object &JScop) {
   }
 
   // Check if the isl_set is a parameter set.
   if (!NewContext.is_params()) {
     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);
+  isl::size OldContextDim = OldContext.dim(isl::dim::param);
+  isl::size NewContextDim = NewContext.dim(isl::dim::param);
 
   // Check if the imported context has the right number of parameters.
   if (OldContextDim != NewContextDim) {
     errs() << "Imported context has the wrong number of parameters : "
-           << "Found " << NewContextDim << " Expected " << OldContextDim
-           << "\n";
+           << "Found " << static_cast<unsigned>(NewContextDim) << " Expected "
+           << static_cast<unsigned>(OldContextDim) << "\n";
     return false;
   }
 
-  for (unsigned i = 0; i < OldContextDim; i++) {
+  for (unsigned i : rangeIslSize(0, OldContextDim)) {
     isl::id Id = OldContext.get_dim_id(isl::dim::param, i);
     NewContext = NewContext.set_dim_id(isl::dim::param, i, Id);
   }
 
   S.setContext(NewContext);
   return true;
 }
 

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

 /// These are automatically generated checked C++ bindings for isl.
 ///
 /// isl is a library for computing with integer sets and maps described by
 /// Presburger formulas. On top of this, isl provides various tools for
 /// polyhedral compilation, ranging from dependence analysis over scheduling
 /// to AST generation.
 
 // clang-format off
 
 #ifndef ISL_CPP_CHECKED
 #define ISL_CPP_CHECKED
 
-#include <isl/id.h>
-#include <isl/space.h>
-#include <isl/val.h>
-#include <isl/aff.h>
-#include <isl/set.h>
-#include <isl/id.h>
-#include <isl/map.h>
-#include <isl/vec.h>
-#include <isl/ilp.h>
-#include <isl/union_set.h>
-#include <isl/union_map.h>
-#include <isl/flow.h>
-#include <isl/schedule.h>
-#include <isl/schedule_node.h>
-#include <isl/ast_build.h>
-#include <isl/fixed_box.h>
-#include <isl/constraint.h>
-#include <isl/polynomial.h>
-#include <isl/mat.h>
-#include <isl/fixed_box.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <isl/set.h>
 
 #include <functional>
+#include <memory>
+#include <ostream>
 #include <string>
+#include <type_traits>
 
 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 used to check that isl::checked::boolean,
+ * isl::checked::stat and isl::checked::size values are checked for errors.
+ */
+struct checker {
+  bool checked = false;
+  ~checker() {
+    //ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
+  }
+};
+
 class boolean {
 private:
-  mutable bool checked = false;
+  mutable std::shared_ptr<checker> check = std::make_shared<checker>();
   isl_bool val;
 
   friend boolean manage(isl_bool val);
   boolean(isl_bool val): val(val) {}
 public:
+  static boolean error() {
+    return boolean(isl_bool_error);
+  }
   boolean()
       : val(isl_bool_error) {}
-  ~boolean() {
-    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
-  }
 
   /* implicit */ boolean(bool val)
       : val(val ? isl_bool_true : isl_bool_false) {}
 
-  bool is_error() const { checked = true; return val == isl_bool_error; }
-  bool is_false() const { checked = true; return val == isl_bool_false; }
-  bool is_true() const { checked = true; return val == isl_bool_true; }
+  isl_bool release() {
+    auto tmp = val;
+    val = isl_bool_error;
+    check->checked = true;
+    return tmp;
+  }
+
+  bool is_error() const { check->checked = true; return val == isl_bool_error; }
+  bool is_false() const { check->checked = true; return val == isl_bool_false; }
+  bool is_true() const { check->checked = true; return val == isl_bool_true; }
 
   operator bool() const {
-    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked error state");
+    //ISLPP_ASSERT(check->checked, "IMPLEMENTATION ERROR: Unchecked error state");
     ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
     return is_true();
   }
 
-  boolean operator!() const {
-    if (is_error())
-      return *this;
-    return !is_true();
+  boolean negate() {
+    if (val == isl_bool_true)
+      val = isl_bool_false;
+    else if (val == isl_bool_false)
+      val = isl_bool_true;
+  }
+
+  boolean operator!() const {
+    return boolean(*this).negate();
   }
 };
 
 inline boolean manage(isl_bool val) {
   return boolean(val);
 }
 
 class ctx {
isl_ctx *get() {
     return ptr;
   }
 };
 
 /* Class encapsulating an isl_stat value.
  */
 class stat {
 private:
-  mutable bool checked = false;
+  mutable std::shared_ptr<checker> check = std::make_shared<checker>();
   isl_stat val;
 
   friend stat manage(isl_stat val);
+  stat(isl_stat val) : val(val) {}
 public:
-  constexpr stat(isl_stat val) : val(val) {}
   static stat ok() {
     return stat(isl_stat_ok);
   }
   static stat error() {
     return stat(isl_stat_error);
   }
   stat() : val(isl_stat_error) {}
-  ~stat() {
-    // ISLPP_ASSERT(checked, "IMPLEMENTATION ERROR: Unchecked state");
-  }
 
   isl_stat release() {
-    checked = true;
+    check->checked = true;
     return val;
   }
 
   bool is_error() const {
-    checked = true;
+    check->checked = true;
     return val == isl_stat_error;
   }
   bool is_ok() const {
-    checked = true;
+    check->checked = true;
     return val == isl_stat_ok;
   }
 };
 
-
 inline stat manage(isl_stat val)
 {
   return stat(val);
 }
 
+/* Class encapsulating an isl_size value.
+ */
+class size {
+private:
+  mutable std::shared_ptr<checker> check = std::make_shared<checker>();
+  isl_size val;
+
+  friend size manage(isl_size val);
+  size(isl_size val) : val(val) {}
+public:
+  size() : val(isl_size_error) {}
+
+  isl_size release() {
+    auto tmp = val;
+    val = isl_size_error;
+    check->checked = true;
+    return tmp;
+  }
+
+  bool is_error() const {
+    check->checked = true;
+    return val == isl_size_error;
+  }
+
+  explicit operator unsigned() const {
+    ISLPP_ASSERT(check->checked,
+          "IMPLEMENTATION ERROR: Unchecked error state");
+    ISLPP_ASSERT(!is_error(),
+          "IMPLEMENTATION ERROR: Unhandled error state");
+    return val;
+  }
+};
+
+inline size manage(isl_size val)
+{
+  return size(val);
+}
+
 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
 };
 
-}
 } // namespace isl
 
-namespace isl {
+#include <isl/id.h>
+#include <isl/space.h>
+#include <isl/val.h>
+#include <isl/aff.h>
+#include <isl/set.h>
+#include <isl/map.h>
+#include <isl/ilp.h>
+#include <isl/constraint.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
+#include <isl/flow.h>
+#include <isl/schedule.h>
+#include <isl/schedule_node.h>
+#include <isl/ast_build.h>
+#include <isl/fixed_box.h>
 
-inline namespace noexceptions {
+namespace isl {
 
 // forward declarations
 class aff;
 class aff_list;
 class ast_build;
 class ast_expr;
-class ast_expr_list;
+class ast_expr_id;
+class ast_expr_int;
+class ast_expr_op;
+class ast_expr_op_access;
+class ast_expr_op_add;
+class ast_expr_op_address_of;
+class ast_expr_op_and;
+class ast_expr_op_and_then;
+class ast_expr_op_call;
+class ast_expr_op_cond;
+class ast_expr_op_div;
+class ast_expr_op_eq;
+class ast_expr_op_fdiv_q;
+class ast_expr_op_ge;
+class ast_expr_op_gt;
+class ast_expr_op_le;
+class ast_expr_op_lt;
+class ast_expr_op_max;
+class ast_expr_op_member;
+class ast_expr_op_min;
+class ast_expr_op_minus;
+class ast_expr_op_mul;
+class ast_expr_op_or;
+class ast_expr_op_or_else;
+class ast_expr_op_pdiv_q;
+class ast_expr_op_pdiv_r;
+class ast_expr_op_select;
+class ast_expr_op_sub;
+class ast_expr_op_zdiv_r;
 class ast_node;
+class ast_node_block;
+class ast_node_for;
+class ast_node_if;
 class ast_node_list;
+class ast_node_mark;
+class ast_node_user;
 class basic_map;
 class basic_map_list;
 class basic_set;
 class basic_set_list;
 class constraint;
-class constraint_list;
 class fixed_box;
 class id;
 class id_list;
 class id_to_ast_expr;
 class local_space;
 class map;
 class map_list;
-class mat;
 class multi_aff;
 class multi_id;
 class multi_pw_aff;
 class multi_union_pw_aff;
 class multi_val;
 class point;
 class pw_aff;
 class pw_aff_list;
 class pw_multi_aff;
 class pw_multi_aff_list;
-class pw_qpolynomial;
-class pw_qpolynomial_fold_list;
-class pw_qpolynomial_list;
-class qpolynomial;
-class qpolynomial_list;
 class schedule;
 class schedule_constraints;
 class schedule_node;
+class schedule_node_band;
+class schedule_node_context;
+class schedule_node_domain;
+class schedule_node_expansion;
+class schedule_node_extension;
+class schedule_node_filter;
+class schedule_node_guard;
+class schedule_node_leaf;
+class schedule_node_mark;
+class schedule_node_sequence;
+class schedule_node_set;
 class set;
 class set_list;
 class space;
-class term;
 class union_access_info;
 class union_flow;
 class union_map;
-class union_map_list;
 class union_pw_aff;
 class union_pw_aff_list;
 class union_pw_multi_aff;
-class union_pw_multi_aff_list;
-class union_pw_qpolynomial;
 class union_set;
 class union_set_list;
 class val;
 class val_list;
-class vec;
 
 // declarations for isl::aff
 inline aff manage(__isl_take isl_aff *ptr);
 inline aff manage_copy(__isl_keep isl_aff *ptr);
 
 class aff {
   friend inline aff manage(__isl_take isl_aff *ptr);
   friend inline aff manage_copy(__isl_keep isl_aff *ptr);
 
+protected:
   isl_aff *ptr = nullptr;
 
   inline explicit aff(__isl_take isl_aff *ptr);
 
 public:
   inline /* implicit */ aff();
   inline /* implicit */ aff(const aff &obj);
   inline explicit aff(isl::ctx ctx, const std::string &str);
   inline explicit aff(isl::local_space ls, isl::val val);
   inline explicit aff(isl::local_space ls);
   inline aff &operator=(aff obj);
   inline ~aff();
   inline __isl_give isl_aff *copy() const &;
   inline __isl_give isl_aff *copy() && = delete;
   inline __isl_keep isl_aff *get() const;
   inline __isl_give isl_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::aff add(isl::aff aff2) const;
-  inline isl::aff add_coefficient_si(isl::dim type, int pos, int v) const;
-  inline isl::aff add_coefficient_val(isl::dim type, int pos, isl::val v) const;
+  inline isl::multi_aff add(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff add(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff add(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_aff add(const isl::pw_aff &pwaff2) const;
+  inline isl::pw_multi_aff add(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_aff add(const isl::union_pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff add(const isl::union_pw_multi_aff &upma2) const;
   inline isl::aff add_constant(isl::val v) const;
-  inline isl::aff add_constant_num_si(int v) const;
+  inline isl::aff add_constant(long v) const;
+  inline isl::multi_aff add_constant(const isl::multi_val &mv) const;
   inline isl::aff add_constant_si(int v) const;
-  inline isl::aff add_dims(isl::dim type, unsigned int n) const;
-  inline isl::aff align_params(isl::space model) const;
+  inline isl::pw_aff add_dims(isl::dim type, unsigned int n) const;
+  inline isl::union_pw_multi_aff add_pw_multi_aff(const isl::pw_multi_aff &pma) const;
+  inline isl::union_pw_multi_aff apply(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::aff as_aff() const;
+  inline isl::map as_map() const;
+  inline isl::multi_aff as_multi_aff() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::union_map as_union_map() const;
+  inline isl::aff at(int pos) const;
   inline isl::basic_set bind(isl::id id) const;
+  inline isl::basic_set bind(const std::string &id) const;
+  inline isl::basic_set bind(const isl::multi_id &tuple) const;
+  inline isl::pw_aff bind_domain(const isl::multi_id &tuple) const;
+  inline isl::pw_aff bind_domain_wrapped_domain(const isl::multi_id &tuple) const;
   inline isl::aff ceil() const;
-  inline int coefficient_sgn(isl::dim type, int pos) const;
-  inline isl_size dim(isl::dim type) const;
+  inline isl::pw_aff coalesce() const;
+  inline isl::pw_aff cond(const isl::pw_aff &pwaff_true, const isl::pw_aff &pwaff_false) const;
+  inline isl::multi_val constant_multi_val() const;
+  inline isl::val constant_val() const;
+  inline isl::val get_constant_val() const;
+  inline isl::val denominator_val() const;
+  inline isl::val get_denominator_val() const;
+  inline class size dim(isl::dim type) const;
+  inline isl::id dim_id(isl::dim type, unsigned int pos) const;
   inline isl::aff div(isl::aff aff2) const;
-  inline isl::aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::basic_set eq_basic_set(isl::aff aff2) const;
+  inline isl::pw_aff div(const isl::pw_aff &pa2) const;
+  inline isl::set domain() const;
+  inline isl::space domain_space() const;
+  inline isl::pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set eq_set(isl::aff aff2) const;
+  inline isl::set eq_set(const 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_multi_aff extract_pw_multi_aff(const isl::space &space) const;
+  inline isl::multi_aff flat_range_product(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff flat_range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff flat_range_product(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff flat_range_product(const isl::union_pw_multi_aff &upma2) const;
   inline isl::aff floor() const;
-  inline isl::aff from_range() const;
-  inline isl::basic_set ge_basic_set(isl::aff aff2) const;
+  inline stat foreach_piece(const std::function<stat(isl::set, isl::aff)> &fn) const;
+  inline stat foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const;
+  inline stat foreach_pw_aff(const std::function<stat(isl::pw_aff)> &fn) const;
   inline isl::set ge_set(isl::aff aff2) const;
-  inline isl::val get_coefficient_val(isl::dim type, int pos) const;
-  inline isl::val get_constant_val() const;
-  inline isl::val get_denominator_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_domain_local_space() const;
-  inline isl::space get_domain_space() const;
-  inline uint32_t get_hash() const;
-  inline isl::local_space get_local_space() const;
-  inline isl::space get_space() const;
+  inline isl::set ge_set(const isl::pw_aff &pwaff2) 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::union_pw_aff gist(const isl::union_set &context) const;
+  inline isl::aff gist(const isl::basic_set &context) const;
+  inline isl::aff gist(const isl::point &context) 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 boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::set gt_set(const isl::pw_aff &pwaff2) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::multi_aff identity() const;
+  inline isl::pw_aff insert_domain(const isl::space &domain) const;
+  inline isl::pw_aff intersect_domain(const isl::set &set) const;
+  inline isl::union_pw_aff intersect_domain(const isl::space &space) const;
+  inline isl::union_pw_aff intersect_domain(const isl::union_set &uset) const;
+  inline isl::union_pw_aff intersect_domain_wrapped_domain(const isl::union_set &uset) const;
+  inline isl::union_pw_aff intersect_domain_wrapped_range(const isl::union_set &uset) const;
+  inline isl::pw_aff intersect_params(const isl::set &set) const;
   inline boolean involves_locals() const;
+  inline boolean involves_nan() const;
+  inline boolean involves_param(const isl::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::id_list &list) const;
   inline boolean is_cst() const;
-  inline boolean is_nan() const;
-  inline isl::basic_set le_basic_set(isl::aff aff2) const;
+  inline boolean is_equal(const isl::pw_aff &pa2) const;
+  inline boolean isa_aff() const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
   inline isl::set le_set(isl::aff aff2) const;
-  inline isl::basic_set lt_basic_set(isl::aff aff2) const;
+  inline isl::set le_set(const isl::pw_aff &pwaff2) const;
+  inline isl::aff_list list() const;
   inline isl::set lt_set(isl::aff aff2) const;
+  inline isl::set lt_set(const isl::pw_aff &pwaff2) const;
+  inline isl::multi_pw_aff max(const isl::multi_pw_aff &multi2) const;
+  inline isl::pw_aff max(const isl::pw_aff &pwaff2) const;
+  inline isl::multi_val max_multi_val() const;
+  inline isl::multi_pw_aff min(const isl::multi_pw_aff &multi2) const;
+  inline isl::pw_aff min(const isl::pw_aff &pwaff2) const;
+  inline isl::multi_val min_multi_val() 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 mod(long mod) const;
   inline isl::aff mul(isl::aff aff2) const;
-  static inline isl::aff nan_on_domain(isl::local_space ls);
-  static inline isl::aff nan_on_domain_space(isl::space space);
+  inline isl::pw_aff mul(const isl::pw_aff &pwaff2) const;
+  inline class size n_piece() const;
   inline isl::set ne_set(isl::aff aff2) const;
+  inline isl::set ne_set(const isl::pw_aff &pwaff2) 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 boolean plain_is_equal(const isl::aff &aff2) const;
-  inline boolean plain_is_zero() const;
-  inline isl::aff project_domain_on_params() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::multi_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_aff product(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff product(const isl::multi_pw_aff &multi2) const;
+  inline isl::pw_multi_aff product(const isl::pw_multi_aff &pma2) const;
   inline isl::aff pullback(isl::multi_aff ma) const;
-  inline isl::aff pullback_aff(isl::aff aff2) const;
+  inline isl::pw_aff pullback(const isl::multi_pw_aff &mpa) const;
+  inline isl::pw_aff pullback(const isl::pw_multi_aff &pma) const;
+  inline isl::union_pw_aff pullback(const isl::union_pw_multi_aff &upma) const;
+  inline isl::aff pullback(const isl::aff &ma) const;
+  inline isl::pw_multi_aff_list pw_multi_aff_list() const;
+  inline isl::pw_multi_aff range_factor_domain() const;
+  inline isl::pw_multi_aff range_factor_range() const;
+  inline isl::multi_aff range_product(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff range_product(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::id range_tuple_id() const;
+  inline isl::multi_aff reset_range_tuple_id() const;
+  inline isl::multi_aff reset_tuple_id(isl::dim type) const;
   inline isl::aff scale(isl::val v) const;
+  inline isl::aff scale(long v) const;
+  inline isl::multi_aff scale(const isl::multi_val &mv) 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;
+  inline isl::aff scale_down(long v) const;
+  inline isl::multi_aff scale_down(const isl::multi_val &mv) const;
+  inline isl::multi_aff set_aff(int pos, const isl::aff &el) const;
+  inline isl::multi_aff set_at(int pos, const isl::aff &el) const;
+  inline isl::multi_pw_aff set_at(int pos, const isl::pw_aff &el) const;
+  inline isl::multi_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) const;
   inline isl::aff set_constant_si(int v) const;
-  inline isl::aff set_constant_val(isl::val v) const;
-  inline isl::aff set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
-  inline isl::aff set_tuple_id(isl::dim type, isl::id id) const;
+  inline isl::multi_pw_aff set_pw_aff(int pos, const isl::pw_aff &el) const;
+  inline isl::pw_multi_aff set_pw_aff(unsigned int pos, const isl::pw_aff &pa) const;
+  inline isl::multi_aff set_range_tuple(const isl::id &id) const;
+  inline isl::multi_aff set_range_tuple(const std::string &id) const;
+  inline isl::pw_aff set_tuple_id(isl::dim type, const isl::id &id) const;
+  inline isl::pw_aff set_tuple_id(isl::dim type, const std::string &id) const;
+  inline isl::multi_union_pw_aff set_union_pw_aff(int pos, const isl::union_pw_aff &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
   inline isl::aff sub(isl::aff aff2) const;
+  inline isl::multi_aff sub(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff sub(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff sub(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_aff sub(const isl::pw_aff &pwaff2) const;
+  inline isl::pw_multi_aff sub(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_aff sub(const isl::union_pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff sub(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_aff subtract_domain(const isl::set &set) const;
+  inline isl::union_pw_aff subtract_domain(const isl::space &space) const;
+  inline isl::union_pw_aff subtract_domain(const isl::union_set &uset) const;
+  inline isl::pw_aff tdiv_q(const isl::pw_aff &pa2) const;
+  inline isl::pw_aff tdiv_r(const isl::pw_aff &pa2) const;
+  inline isl::aff_list to_list() const;
+  inline isl::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::multi_union_pw_aff to_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff to_pw_multi_aff() const;
+  inline isl::union_pw_aff to_union_pw_aff() const;
+  inline isl::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::id tuple_id(isl::dim type) const;
   inline isl::aff unbind_params_insert_domain(isl::multi_id domain) const;
-  static inline isl::aff val_on_domain_space(isl::space space, isl::val val);
+  inline isl::multi_pw_aff union_add(const isl::multi_pw_aff &mpa2) const;
+  inline isl::multi_union_pw_aff union_add(const isl::multi_union_pw_aff &mupa2) const;
+  inline isl::pw_aff union_add(const isl::pw_aff &pwaff2) const;
+  inline isl::pw_multi_aff union_add(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_aff union_add(const isl::union_pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff union_add(const isl::union_pw_multi_aff &upma2) const;
   static inline isl::aff var_on_domain(isl::local_space ls, isl::dim type, unsigned int pos);
-  inline isl::basic_set zero_basic_set() const;
   static inline isl::aff zero_on_domain(isl::space space);
 };
 
 // declarations for isl::aff_list
 inline aff_list manage(__isl_take isl_aff_list *ptr);
 inline aff_list manage_copy(__isl_keep isl_aff_list *ptr);
 
 class aff_list {
   friend inline aff_list manage(__isl_take isl_aff_list *ptr);
   friend inline aff_list manage_copy(__isl_keep isl_aff_list *ptr);
 
+protected:
   isl_aff_list *ptr = nullptr;
 
   inline explicit aff_list(__isl_take isl_aff_list *ptr);
 
 public:
   inline /* implicit */ aff_list();
   inline /* implicit */ aff_list(const aff_list &obj);
+  inline explicit aff_list(isl::ctx ctx, int n);
+  inline explicit aff_list(isl::aff el);
+  inline explicit aff_list(isl::ctx ctx, const std::string &str);
   inline aff_list &operator=(aff_list obj);
   inline ~aff_list();
   inline __isl_give isl_aff_list *copy() const &;
   inline __isl_give isl_aff_list *copy() && = delete;
   inline __isl_keep isl_aff_list *get() const;
   inline __isl_give isl_aff_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::aff_list add(isl::aff el) const;
-  static inline isl::aff_list alloc(isl::ctx ctx, int n);
+  inline isl::aff at(int index) const;
+  inline isl::aff get_at(int index) const;
   inline isl::aff_list clear() const;
   inline isl::aff_list concat(isl::aff_list list2) const;
   inline isl::aff_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(aff)> &fn) const;
-  static inline isl::aff_list from_aff(isl::aff el);
-  inline isl::aff get_aff(int index) const;
-  inline isl::aff get_at(int index) const;
+  inline stat foreach(const std::function<stat(isl::aff)> &fn) const;
   inline isl::aff_list insert(unsigned int pos, isl::aff el) const;
-  inline isl_size n_aff() const;
-  inline isl::aff_list reverse() const;
-  inline isl::aff_list set_aff(int index, isl::aff el) const;
-  inline isl_size size() const;
-  inline isl::aff_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
 };
 
 // declarations for isl::ast_build
 inline ast_build manage(__isl_take isl_ast_build *ptr);
 inline ast_build manage_copy(__isl_keep isl_ast_build *ptr);
 
 class ast_build {
   friend inline ast_build manage(__isl_take isl_ast_build *ptr);
   friend inline ast_build manage_copy(__isl_keep isl_ast_build *ptr);
 
+protected:
   isl_ast_build *ptr = nullptr;
 
   inline explicit ast_build(__isl_take isl_ast_build *ptr);
 
 public:
   inline /* implicit */ ast_build();
   inline /* implicit */ ast_build(const ast_build &obj);
   inline explicit ast_build(isl::ctx ctx);
   inline ast_build &operator=(ast_build obj);
   inline ~ast_build();
   inline __isl_give isl_ast_build *copy() const &;
   inline __isl_give isl_ast_build *copy() && = delete;
   inline __isl_keep isl_ast_build *get() const;
   inline __isl_give isl_ast_build *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
 
+private:
+  inline ast_build &copy_callbacks(const ast_build &obj);
+  struct at_each_domain_data {
+    std::function<isl::ast_node(isl::ast_node, isl::ast_build)> func;
+  };
+  std::shared_ptr<at_each_domain_data> at_each_domain_data;
+  static inline isl_ast_node *at_each_domain(isl_ast_node *arg_0, isl_ast_build *arg_1, void *arg_2);
+  inline void set_at_each_domain_data(const std::function<isl::ast_node(isl::ast_node, isl::ast_build)> &fn);
+public:
+  inline isl::ast_build set_at_each_domain(const std::function<isl::ast_node(isl::ast_node, isl::ast_build)> &fn) const;
   inline isl::ast_expr access_from(isl::multi_pw_aff mpa) const;
   inline isl::ast_expr access_from(isl::pw_multi_aff pma) const;
-  inline isl::ast_node ast_from_schedule(isl::union_map schedule) const;
   inline isl::ast_expr call_from(isl::multi_pw_aff mpa) const;
   inline isl::ast_expr call_from(isl::pw_multi_aff pma) const;
   inline isl::ast_expr expr_from(isl::pw_aff pa) const;
   inline isl::ast_expr expr_from(isl::set set) const;
   static inline isl::ast_build from_context(isl::set set);
-  inline isl::union_map get_schedule() const;
-  inline isl::space get_schedule_space() const;
   inline isl::ast_node node_from(isl::schedule schedule) const;
   inline isl::ast_node node_from_schedule_map(isl::union_map schedule) const;
   inline isl::ast_build restrict(isl::set set) const;
+  inline isl::union_map schedule() const;
+  inline isl::union_map get_schedule() const;
 };
 
 // declarations for isl::ast_expr
 inline ast_expr manage(__isl_take isl_ast_expr *ptr);
 inline ast_expr manage_copy(__isl_keep isl_ast_expr *ptr);
 
 class ast_expr {
   friend inline ast_expr manage(__isl_take isl_ast_expr *ptr);
   friend inline ast_expr manage_copy(__isl_keep isl_ast_expr *ptr);
 
+protected:
   isl_ast_expr *ptr = nullptr;
 
   inline explicit ast_expr(__isl_take isl_ast_expr *ptr);
 
 public:
   inline /* implicit */ ast_expr();
   inline /* implicit */ ast_expr(const ast_expr &obj);
   inline ast_expr &operator=(ast_expr obj);
   inline ~ast_expr();
   inline __isl_give isl_ast_expr *copy() const &;
   inline __isl_give isl_ast_expr *copy() && = delete;
   inline __isl_keep isl_ast_expr *get() const;
   inline __isl_give isl_ast_expr *release();
   inline bool is_null() const;
+private:
+  template <typename T,
+          typename = typename std::enable_if<std::is_same<
+                  const decltype(isl_ast_expr_get_type(NULL)),
+                  const T>::value>::type>
+  inline boolean isa_type(T subtype) const;
+public:
+  template <class T> inline boolean isa() const;
+  template <class T> inline T as() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::ast_expr access(isl::ast_expr_list indices) const;
   inline isl::ast_expr add(isl::ast_expr expr2) const;
   inline isl::ast_expr address_of() const;
-  inline isl::ast_expr call(isl::ast_expr_list arguments) const;
-  inline isl::ast_expr div(isl::ast_expr expr2) const;
   inline isl::ast_expr eq(isl::ast_expr expr2) const;
-  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 id() const;
   inline isl::id get_id() const;
-  inline isl::ast_expr get_op_arg(int pos) const;
-  inline isl_size get_op_n_arg() const;
-  inline isl::val get_val() const;
-  inline isl::ast_expr gt(isl::ast_expr expr2) const;
-  inline isl::id id_get_id() const;
-  inline isl::val int_get_val() const;
-  inline boolean is_equal(const isl::ast_expr &expr2) 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 op_get_arg(int pos) const;
-  inline isl_size op_get_n_arg() 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;
-  inline isl::ast_expr substitute_ids(isl::id_to_ast_expr id2expr) const;
+  inline isl::ast_expr op_arg(int pos) const;
+  inline isl::ast_expr get_op_arg(int pos) const;
   inline std::string to_C_str() const;
+  inline isl::val val() const;
+  inline isl::val get_val() const;
 };
 
-// declarations for isl::ast_expr_list
-inline ast_expr_list manage(__isl_take isl_ast_expr_list *ptr);
-inline ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr);
-
-class ast_expr_list {
-  friend inline ast_expr_list manage(__isl_take isl_ast_expr_list *ptr);
-  friend inline ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr);
-
-  isl_ast_expr_list *ptr = nullptr;
-
-  inline explicit ast_expr_list(__isl_take isl_ast_expr_list *ptr);
-
-public:
-  inline /* implicit */ ast_expr_list();
-  inline /* implicit */ ast_expr_list(const ast_expr_list &obj);
-  inline ast_expr_list &operator=(ast_expr_list obj);
-  inline ~ast_expr_list();
-  inline __isl_give isl_ast_expr_list *copy() const &;
-  inline __isl_give isl_ast_expr_list *copy() && = delete;
-  inline __isl_keep isl_ast_expr_list *get() const;
-  inline __isl_give isl_ast_expr_list *release();
-  inline bool is_null() const;
+// declarations for isl::ast_expr_id
+
+class ast_expr_id : public ast_expr {
+  template <class T>
+  friend boolean ast_expr::isa() const;
+  friend ast_expr_id ast_expr::as<ast_expr_id>() const;
+  static const auto type = isl_ast_expr_id;
+
+protected:
+  inline explicit ast_expr_id(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_id();
+  inline /* implicit */ ast_expr_id(const ast_expr_id &obj);
+  inline ast_expr_id &operator=(ast_expr_id obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::id id() const;
+  inline isl::id get_id() const;
+};
+
+// declarations for isl::ast_expr_int
+
+class ast_expr_int : public ast_expr {
+  template <class T>
+  friend boolean ast_expr::isa() const;
+  friend ast_expr_int ast_expr::as<ast_expr_int>() const;
+  static const auto type = isl_ast_expr_int;
+
+protected:
+  inline explicit ast_expr_int(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_int();
+  inline /* implicit */ ast_expr_int(const ast_expr_int &obj);
+  inline ast_expr_int &operator=(ast_expr_int obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::val val() const;
+  inline isl::val get_val() const;
+};
+
+// declarations for isl::ast_expr_op
+
+class ast_expr_op : public ast_expr {
+  template <class T>
+  friend boolean ast_expr::isa() const;
+  friend ast_expr_op ast_expr::as<ast_expr_op>() const;
+  static const auto type = isl_ast_expr_op;
+
+protected:
+  inline explicit ast_expr_op(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op();
+  inline /* implicit */ ast_expr_op(const ast_expr_op &obj);
+  inline ast_expr_op &operator=(ast_expr_op obj);
+private:
+  template <typename T,
+          typename = typename std::enable_if<std::is_same<
+                  const decltype(isl_ast_expr_op_get_type(NULL)),
+                  const T>::value>::type>
+  inline boolean isa_type(T subtype) const;
+public:
+  template <class T> inline boolean isa() const;
+  template <class T> inline T as() const;
+  inline isl::ctx ctx() const;
+
+  inline isl::ast_expr arg(int pos) const;
+  inline isl::ast_expr get_arg(int pos) const;
+  inline class size n_arg() const;
+  inline class size get_n_arg() const;
+};
+
+// declarations for isl::ast_expr_op_access
+
+class ast_expr_op_access : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_access ast_expr_op::as<ast_expr_op_access>() const;
+  static const auto type = isl_ast_expr_op_access;
+
+protected:
+  inline explicit ast_expr_op_access(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_access();
+  inline /* implicit */ ast_expr_op_access(const ast_expr_op_access &obj);
+  inline ast_expr_op_access &operator=(ast_expr_op_access obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_add
+
+class ast_expr_op_add : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_add ast_expr_op::as<ast_expr_op_add>() const;
+  static const auto type = isl_ast_expr_op_add;
+
+protected:
+  inline explicit ast_expr_op_add(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_add();
+  inline /* implicit */ ast_expr_op_add(const ast_expr_op_add &obj);
+  inline ast_expr_op_add &operator=(ast_expr_op_add obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_address_of
+
+class ast_expr_op_address_of : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_address_of ast_expr_op::as<ast_expr_op_address_of>() const;
+  static const auto type = isl_ast_expr_op_address_of;
+
+protected:
+  inline explicit ast_expr_op_address_of(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_address_of();
+  inline /* implicit */ ast_expr_op_address_of(const ast_expr_op_address_of &obj);
+  inline ast_expr_op_address_of &operator=(ast_expr_op_address_of obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_and
+
+class ast_expr_op_and : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_and ast_expr_op::as<ast_expr_op_and>() const;
+  static const auto type = isl_ast_expr_op_and;
+
+protected:
+  inline explicit ast_expr_op_and(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_and();
+  inline /* implicit */ ast_expr_op_and(const ast_expr_op_and &obj);
+  inline ast_expr_op_and &operator=(ast_expr_op_and obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_and_then
+
+class ast_expr_op_and_then : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_and_then ast_expr_op::as<ast_expr_op_and_then>() const;
+  static const auto type = isl_ast_expr_op_and_then;
+
+protected:
+  inline explicit ast_expr_op_and_then(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_and_then();
+  inline /* implicit */ ast_expr_op_and_then(const ast_expr_op_and_then &obj);
+  inline ast_expr_op_and_then &operator=(ast_expr_op_and_then obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_call
+
+class ast_expr_op_call : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_call ast_expr_op::as<ast_expr_op_call>() const;
+  static const auto type = isl_ast_expr_op_call;
+
+protected:
+  inline explicit ast_expr_op_call(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_call();
+  inline /* implicit */ ast_expr_op_call(const ast_expr_op_call &obj);
+  inline ast_expr_op_call &operator=(ast_expr_op_call obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_cond
+
+class ast_expr_op_cond : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_cond ast_expr_op::as<ast_expr_op_cond>() const;
+  static const auto type = isl_ast_expr_op_cond;
+
+protected:
+  inline explicit ast_expr_op_cond(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_cond();
+  inline /* implicit */ ast_expr_op_cond(const ast_expr_op_cond &obj);
+  inline ast_expr_op_cond &operator=(ast_expr_op_cond obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_div
+
+class ast_expr_op_div : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_div ast_expr_op::as<ast_expr_op_div>() const;
+  static const auto type = isl_ast_expr_op_div;
+
+protected:
+  inline explicit ast_expr_op_div(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_div();
+  inline /* implicit */ ast_expr_op_div(const ast_expr_op_div &obj);
+  inline ast_expr_op_div &operator=(ast_expr_op_div obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_eq
+
+class ast_expr_op_eq : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_eq ast_expr_op::as<ast_expr_op_eq>() const;
+  static const auto type = isl_ast_expr_op_eq;
+
+protected:
+  inline explicit ast_expr_op_eq(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_eq();
+  inline /* implicit */ ast_expr_op_eq(const ast_expr_op_eq &obj);
+  inline ast_expr_op_eq &operator=(ast_expr_op_eq obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_fdiv_q
+
+class ast_expr_op_fdiv_q : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_fdiv_q ast_expr_op::as<ast_expr_op_fdiv_q>() const;
+  static const auto type = isl_ast_expr_op_fdiv_q;
+
+protected:
+  inline explicit ast_expr_op_fdiv_q(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_fdiv_q();
+  inline /* implicit */ ast_expr_op_fdiv_q(const ast_expr_op_fdiv_q &obj);
+  inline ast_expr_op_fdiv_q &operator=(ast_expr_op_fdiv_q obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_ge
+
+class ast_expr_op_ge : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_ge ast_expr_op::as<ast_expr_op_ge>() const;
+  static const auto type = isl_ast_expr_op_ge;
+
+protected:
+  inline explicit ast_expr_op_ge(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_ge();
+  inline /* implicit */ ast_expr_op_ge(const ast_expr_op_ge &obj);
+  inline ast_expr_op_ge &operator=(ast_expr_op_ge obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_gt
+
+class ast_expr_op_gt : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_gt ast_expr_op::as<ast_expr_op_gt>() const;
+  static const auto type = isl_ast_expr_op_gt;
+
+protected:
+  inline explicit ast_expr_op_gt(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_gt();
+  inline /* implicit */ ast_expr_op_gt(const ast_expr_op_gt &obj);
+  inline ast_expr_op_gt &operator=(ast_expr_op_gt obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_le
+
+class ast_expr_op_le : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_le ast_expr_op::as<ast_expr_op_le>() const;
+  static const auto type = isl_ast_expr_op_le;
+
+protected:
+  inline explicit ast_expr_op_le(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_le();
+  inline /* implicit */ ast_expr_op_le(const ast_expr_op_le &obj);
+  inline ast_expr_op_le &operator=(ast_expr_op_le obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_lt
+
+class ast_expr_op_lt : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_lt ast_expr_op::as<ast_expr_op_lt>() const;
+  static const auto type = isl_ast_expr_op_lt;
+
+protected:
+  inline explicit ast_expr_op_lt(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_lt();
+  inline /* implicit */ ast_expr_op_lt(const ast_expr_op_lt &obj);
+  inline ast_expr_op_lt &operator=(ast_expr_op_lt obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_max
+
+class ast_expr_op_max : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_max ast_expr_op::as<ast_expr_op_max>() const;
+  static const auto type = isl_ast_expr_op_max;
+
+protected:
+  inline explicit ast_expr_op_max(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_max();
+  inline /* implicit */ ast_expr_op_max(const ast_expr_op_max &obj);
+  inline ast_expr_op_max &operator=(ast_expr_op_max obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_member
+
+class ast_expr_op_member : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_member ast_expr_op::as<ast_expr_op_member>() const;
+  static const auto type = isl_ast_expr_op_member;
+
+protected:
+  inline explicit ast_expr_op_member(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_member();
+  inline /* implicit */ ast_expr_op_member(const ast_expr_op_member &obj);
+  inline ast_expr_op_member &operator=(ast_expr_op_member obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_min
+
+class ast_expr_op_min : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_min ast_expr_op::as<ast_expr_op_min>() const;
+  static const auto type = isl_ast_expr_op_min;
+
+protected:
+  inline explicit ast_expr_op_min(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_min();
+  inline /* implicit */ ast_expr_op_min(const ast_expr_op_min &obj);
+  inline ast_expr_op_min &operator=(ast_expr_op_min obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_minus
+
+class ast_expr_op_minus : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_minus ast_expr_op::as<ast_expr_op_minus>() const;
+  static const auto type = isl_ast_expr_op_minus;
+
+protected:
+  inline explicit ast_expr_op_minus(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_minus();
+  inline /* implicit */ ast_expr_op_minus(const ast_expr_op_minus &obj);
+  inline ast_expr_op_minus &operator=(ast_expr_op_minus obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_mul
+
+class ast_expr_op_mul : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_mul ast_expr_op::as<ast_expr_op_mul>() const;
+  static const auto type = isl_ast_expr_op_mul;
+
+protected:
+  inline explicit ast_expr_op_mul(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_mul();
+  inline /* implicit */ ast_expr_op_mul(const ast_expr_op_mul &obj);
+  inline ast_expr_op_mul &operator=(ast_expr_op_mul obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_or
+
+class ast_expr_op_or : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_or ast_expr_op::as<ast_expr_op_or>() const;
+  static const auto type = isl_ast_expr_op_or;
+
+protected:
+  inline explicit ast_expr_op_or(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_or();
+  inline /* implicit */ ast_expr_op_or(const ast_expr_op_or &obj);
+  inline ast_expr_op_or &operator=(ast_expr_op_or obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_or_else
+
+class ast_expr_op_or_else : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_or_else ast_expr_op::as<ast_expr_op_or_else>() const;
+  static const auto type = isl_ast_expr_op_or_else;
+
+protected:
+  inline explicit ast_expr_op_or_else(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_or_else();
+  inline /* implicit */ ast_expr_op_or_else(const ast_expr_op_or_else &obj);
+  inline ast_expr_op_or_else &operator=(ast_expr_op_or_else obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_pdiv_q
+
+class ast_expr_op_pdiv_q : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_pdiv_q ast_expr_op::as<ast_expr_op_pdiv_q>() const;
+  static const auto type = isl_ast_expr_op_pdiv_q;
+
+protected:
+  inline explicit ast_expr_op_pdiv_q(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_pdiv_q();
+  inline /* implicit */ ast_expr_op_pdiv_q(const ast_expr_op_pdiv_q &obj);
+  inline ast_expr_op_pdiv_q &operator=(ast_expr_op_pdiv_q obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_pdiv_r
+
+class ast_expr_op_pdiv_r : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_pdiv_r ast_expr_op::as<ast_expr_op_pdiv_r>() const;
+  static const auto type = isl_ast_expr_op_pdiv_r;
+
+protected:
+  inline explicit ast_expr_op_pdiv_r(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_pdiv_r();
+  inline /* implicit */ ast_expr_op_pdiv_r(const ast_expr_op_pdiv_r &obj);
+  inline ast_expr_op_pdiv_r &operator=(ast_expr_op_pdiv_r obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_select
+
+class ast_expr_op_select : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_select ast_expr_op::as<ast_expr_op_select>() const;
+  static const auto type = isl_ast_expr_op_select;
+
+protected:
+  inline explicit ast_expr_op_select(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_select();
+  inline /* implicit */ ast_expr_op_select(const ast_expr_op_select &obj);
+  inline ast_expr_op_select &operator=(ast_expr_op_select obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_sub
+
+class ast_expr_op_sub : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_sub ast_expr_op::as<ast_expr_op_sub>() const;
+  static const auto type = isl_ast_expr_op_sub;
+
+protected:
+  inline explicit ast_expr_op_sub(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_sub();
+  inline /* implicit */ ast_expr_op_sub(const ast_expr_op_sub &obj);
+  inline ast_expr_op_sub &operator=(ast_expr_op_sub obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::ast_expr_op_zdiv_r
+
+class ast_expr_op_zdiv_r : public ast_expr_op {
+  template <class T>
+  friend boolean ast_expr_op::isa() const;
+  friend ast_expr_op_zdiv_r ast_expr_op::as<ast_expr_op_zdiv_r>() const;
+  static const auto type = isl_ast_expr_op_zdiv_r;
+
+protected:
+  inline explicit ast_expr_op_zdiv_r(__isl_take isl_ast_expr *ptr);
+
+public:
+  inline /* implicit */ ast_expr_op_zdiv_r();
+  inline /* implicit */ ast_expr_op_zdiv_r(const ast_expr_op_zdiv_r &obj);
+  inline ast_expr_op_zdiv_r &operator=(ast_expr_op_zdiv_r obj);
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::ast_expr_list add(isl::ast_expr el) const;
-  static inline isl::ast_expr_list alloc(isl::ctx ctx, int n);
-  inline isl::ast_expr_list clear() const;
-  inline isl::ast_expr_list concat(isl::ast_expr_list list2) const;
-  inline isl::ast_expr_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(ast_expr)> &fn) const;
-  static inline isl::ast_expr_list from_ast_expr(isl::ast_expr el);
-  inline isl::ast_expr get_ast_expr(int index) const;
-  inline isl::ast_expr get_at(int index) const;
-  inline isl::ast_expr_list insert(unsigned int pos, isl::ast_expr el) const;
-  inline isl_size n_ast_expr() const;
-  inline isl::ast_expr_list reverse() const;
-  inline isl::ast_expr_list set_ast_expr(int index, isl::ast_expr el) const;
-  inline isl_size size() const;
-  inline isl::ast_expr_list swap(unsigned int pos1, unsigned int pos2) const;
 };
 
 // declarations for isl::ast_node
 inline ast_node manage(__isl_take isl_ast_node *ptr);
 inline ast_node manage_copy(__isl_keep isl_ast_node *ptr);
 
 class ast_node {
   friend inline ast_node manage(__isl_take isl_ast_node *ptr);
   friend inline ast_node manage_copy(__isl_keep isl_ast_node *ptr);
 
+protected:
   isl_ast_node *ptr = nullptr;
 
   inline explicit ast_node(__isl_take isl_ast_node *ptr);
 
 public:
   inline /* implicit */ ast_node();
   inline /* implicit */ ast_node(const ast_node &obj);
   inline ast_node &operator=(ast_node obj);
   inline ~ast_node();
   inline __isl_give isl_ast_node *copy() const &;
   inline __isl_give isl_ast_node *copy() && = delete;
   inline __isl_keep isl_ast_node *get() const;
   inline __isl_give isl_ast_node *release();
   inline bool is_null() const;
+private:
+  template <typename T,
+          typename = typename std::enable_if<std::is_same<
+                  const decltype(isl_ast_node_get_type(NULL)),
+                  const T>::value>::type>
+  inline boolean isa_type(T subtype) const;
+public:
+  template <class T> inline boolean isa() const;
+  template <class T> inline T as() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  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 boolean for_is_degenerate() const;
+  inline isl::id annotation() 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_else_node() const;
-  inline isl::ast_node if_get_then() const;
-  inline isl::ast_node if_get_then_node() const;
-  inline boolean if_has_else() const;
-  inline boolean if_has_else_node() 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;
+  inline isl::ast_node_list to_list() const;
+};
+
+// declarations for isl::ast_node_block
+
+class ast_node_block : public ast_node {
+  template <class T>
+  friend boolean ast_node::isa() const;
+  friend ast_node_block ast_node::as<ast_node_block>() const;
+  static const auto type = isl_ast_node_block;
+
+protected:
+  inline explicit ast_node_block(__isl_take isl_ast_node *ptr);
+
+public:
+  inline /* implicit */ ast_node_block();
+  inline /* implicit */ ast_node_block(const ast_node_block &obj);
+  inline ast_node_block &operator=(ast_node_block obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::ast_node_list children() const;
+  inline isl::ast_node_list get_children() const;
+};
+
+// declarations for isl::ast_node_for
+
+class ast_node_for : public ast_node {
+  template <class T>
+  friend boolean ast_node::isa() const;
+  friend ast_node_for ast_node::as<ast_node_for>() const;
+  static const auto type = isl_ast_node_for;
+
+protected:
+  inline explicit ast_node_for(__isl_take isl_ast_node *ptr);
+
+public:
+  inline /* implicit */ ast_node_for();
+  inline /* implicit */ ast_node_for(const ast_node_for &obj);
+  inline ast_node_for &operator=(ast_node_for obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::ast_node body() const;
+  inline isl::ast_node get_body() const;
+  inline isl::ast_expr cond() const;
+  inline isl::ast_expr get_cond() const;
+  inline isl::ast_expr inc() const;
+  inline isl::ast_expr get_inc() const;
+  inline isl::ast_expr init() const;
+  inline isl::ast_expr get_init() const;
+  inline boolean is_degenerate() const;
+  inline isl::ast_expr iterator() const;
+  inline isl::ast_expr get_iterator() const;
+};
+
+// declarations for isl::ast_node_if
+
+class ast_node_if : public ast_node {
+  template <class T>
+  friend boolean ast_node::isa() const;
+  friend ast_node_if ast_node::as<ast_node_if>() const;
+  static const auto type = isl_ast_node_if;
+
+protected:
+  inline explicit ast_node_if(__isl_take isl_ast_node *ptr);
+
+public:
+  inline /* implicit */ ast_node_if();
+  inline /* implicit */ ast_node_if(const ast_node_if &obj);
+  inline ast_node_if &operator=(ast_node_if obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::ast_expr cond() const;
+  inline isl::ast_expr get_cond() const;
+  inline isl::ast_node else_node() const;
+  inline isl::ast_node get_else_node() const;
+  inline boolean has_else_node() const;
+  inline isl::ast_node then_node() const;
+  inline isl::ast_node get_then_node() const;
 };
 
 // declarations for isl::ast_node_list
 inline ast_node_list manage(__isl_take isl_ast_node_list *ptr);
 inline ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr);
 
 class ast_node_list {
   friend inline ast_node_list manage(__isl_take isl_ast_node_list *ptr);
   friend inline ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr);
 
+protected:
   isl_ast_node_list *ptr = nullptr;
 
   inline explicit ast_node_list(__isl_take isl_ast_node_list *ptr);
 
 public:
   inline /* implicit */ ast_node_list();
   inline /* implicit */ ast_node_list(const ast_node_list &obj);
+  inline explicit ast_node_list(isl::ctx ctx, int n);
+  inline explicit ast_node_list(isl::ast_node el);
   inline ast_node_list &operator=(ast_node_list obj);
   inline ~ast_node_list();
   inline __isl_give isl_ast_node_list *copy() const &;
   inline __isl_give isl_ast_node_list *copy() && = delete;
   inline __isl_keep isl_ast_node_list *get() const;
   inline __isl_give isl_ast_node_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::ast_node_list add(isl::ast_node el) const;
-  static inline isl::ast_node_list alloc(isl::ctx ctx, int n);
+  inline isl::ast_node at(int index) const;
+  inline isl::ast_node get_at(int index) const;
   inline isl::ast_node_list clear() const;
   inline isl::ast_node_list concat(isl::ast_node_list list2) const;
   inline isl::ast_node_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(ast_node)> &fn) const;
-  static inline isl::ast_node_list from_ast_node(isl::ast_node el);
-  inline isl::ast_node get_ast_node(int index) const;
-  inline isl::ast_node get_at(int index) const;
+  inline stat foreach(const std::function<stat(isl::ast_node)> &fn) const;
   inline isl::ast_node_list insert(unsigned int pos, isl::ast_node el) const;
-  inline isl_size n_ast_node() const;
-  inline isl::ast_node_list reverse() const;
-  inline isl::ast_node_list set_ast_node(int index, isl::ast_node el) const;
-  inline isl_size size() const;
-  inline isl::ast_node_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
+};
+
+// declarations for isl::ast_node_mark
+
+class ast_node_mark : public ast_node {
+  template <class T>
+  friend boolean ast_node::isa() const;
+  friend ast_node_mark ast_node::as<ast_node_mark>() const;
+  static const auto type = isl_ast_node_mark;
+
+protected:
+  inline explicit ast_node_mark(__isl_take isl_ast_node *ptr);
+
+public:
+  inline /* implicit */ ast_node_mark();
+  inline /* implicit */ ast_node_mark(const ast_node_mark &obj);
+  inline ast_node_mark &operator=(ast_node_mark obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::id id() const;
+  inline isl::id get_id() const;
+  inline isl::ast_node node() const;
+  inline isl::ast_node get_node() const;
+};
+
+// declarations for isl::ast_node_user
+
+class ast_node_user : public ast_node {
+  template <class T>
+  friend boolean ast_node::isa() const;
+  friend ast_node_user ast_node::as<ast_node_user>() const;
+  static const auto type = isl_ast_node_user;
+
+protected:
+  inline explicit ast_node_user(__isl_take isl_ast_node *ptr);
+
+public:
+  inline /* implicit */ ast_node_user();
+  inline /* implicit */ ast_node_user(const ast_node_user &obj);
+  inline ast_node_user &operator=(ast_node_user obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::ast_expr expr() const;
+  inline isl::ast_expr get_expr() const;
 };
 
 // declarations for isl::basic_map
 inline basic_map manage(__isl_take isl_basic_map *ptr);
 inline basic_map manage_copy(__isl_keep isl_basic_map *ptr);
 
 class basic_map {
   friend inline basic_map manage(__isl_take isl_basic_map *ptr);
   friend inline basic_map manage_copy(__isl_keep isl_basic_map *ptr);
 
+protected:
   isl_basic_map *ptr = nullptr;
 
   inline explicit basic_map(__isl_take isl_basic_map *ptr);
 
 public:
   inline /* implicit */ basic_map();
   inline /* implicit */ basic_map(const basic_map &obj);
   inline explicit basic_map(isl::ctx ctx, const std::string &str);
   inline basic_map &operator=(basic_map obj);
   inline ~basic_map();
   inline __isl_give isl_basic_map *copy() const &;
   inline __isl_give isl_basic_map *copy() && = delete;
   inline __isl_keep isl_basic_map *get() const;
   inline __isl_give isl_basic_map *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  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::map add_constraint(const 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::basic_map align_params(isl::space model) const;
+  inline isl::map align_params(const isl::space &model) const;
   inline isl::basic_map apply_domain(isl::basic_map bmap2) const;
+  inline isl::map apply_domain(const isl::map &map2) const;
+  inline isl::union_map apply_domain(const isl::union_map &umap2) const;
   inline isl::basic_map apply_range(isl::basic_map bmap2) const;
+  inline isl::map apply_range(const isl::map &map2) const;
+  inline isl::union_map apply_range(const isl::union_map &umap2) const;
+  inline isl::map as_map() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::union_pw_multi_aff as_union_pw_multi_aff() const;
+  inline isl::basic_map_list basic_map_list() const;
+  inline isl::set bind_domain(const isl::multi_id &tuple) const;
+  inline isl::set bind_range(const isl::multi_id &tuple) const;
   inline boolean can_curry() const;
-  inline boolean can_uncurry() const;
-  inline boolean can_zip() const;
-  inline isl::basic_map curry() const;
+  inline isl::map coalesce() const;
+  inline isl::map complement() const;
+  inline isl::union_map compute_divs() const;
+  inline isl::map curry() const;
   inline isl::basic_set deltas() const;
-  inline isl::basic_map deltas_map() const;
   inline isl::basic_map detect_equalities() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size 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::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);
+  inline isl::map domain_factor_domain() const;
+  inline isl::map domain_factor_range() const;
+  inline isl::map domain_map() const;
+  inline isl::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
+  inline isl::map domain_product(const isl::map &map2) const;
+  inline isl::union_map domain_product(const isl::union_map &umap2) const;
+  inline class size domain_tuple_dim() const;
+  inline isl::id domain_tuple_id() const;
+  inline isl::map eq_at(const isl::multi_pw_aff &mpa) const;
+  inline isl::union_map eq_at(const isl::multi_union_pw_aff &mupa) const;
   static inline isl::basic_map equal(isl::space space, unsigned int n_equal);
-  inline isl::mat equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const;
   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 boolean every_map(const std::function<boolean(isl::map)> &test) const;
+  inline isl::map extract_map(const isl::space &space) const;
+  inline isl::map factor_domain() const;
+  inline isl::map factor_range() 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 fix_val(isl::dim type, unsigned int pos, long v) const;
+  inline isl::union_map fixed_power(const isl::val &exp) const;
+  inline isl::union_map fixed_power(long exp) const;
+  inline isl::map flat_range_product(const isl::map &map2) const;
+  inline isl::union_map flat_range_product(const isl::union_map &umap2) const;
   inline isl::basic_map flatten() const;
   inline isl::basic_map flatten_domain() const;
   inline isl::basic_map flatten_range() const;
-  inline stat foreach_constraint(const std::function<stat(constraint)> &fn) const;
+  inline isl::map floordiv_val(const isl::val &d) const;
+  inline isl::map floordiv_val(long d) const;
+  inline stat foreach_basic_map(const std::function<stat(isl::basic_map)> &fn) const;
+  inline stat foreach_map(const std::function<stat(isl::map)> &fn) const;
   static inline isl::basic_map from_aff(isl::aff aff);
-  static inline isl::basic_map from_aff_list(isl::space domain_space, 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 boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  static inline isl::basic_map identity(isl::space space);
-  inline boolean image_is_bounded() const;
-  inline isl::mat inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const;
-  inline isl::basic_map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
+  inline isl::map gist(const isl::map &context) const;
+  inline isl::union_map gist(const isl::union_map &context) const;
+  inline isl::map gist_domain(const isl::set &context) const;
+  inline isl::union_map gist_domain(const isl::union_set &uset) const;
+  inline isl::map gist_params(const isl::set &context) const;
+  inline isl::union_map gist_range(const isl::union_set &uset) const;
+  inline boolean has_domain_tuple_id() const;
+  inline boolean has_equal_space(const isl::map &map2) const;
+  inline boolean has_range_tuple_id() const;
+  inline boolean has_tuple_id(isl::dim type) const;
+  inline boolean has_tuple_name(isl::dim type) const;
   inline isl::basic_map intersect(isl::basic_map bmap2) const;
+  inline isl::map intersect(const isl::map &map2) const;
+  inline isl::union_map intersect(const isl::union_map &umap2) const;
   inline isl::basic_map intersect_domain(isl::basic_set bset) const;
+  inline isl::map intersect_domain(const isl::set &set) const;
+  inline isl::union_map intersect_domain(const isl::space &space) const;
+  inline isl::union_map intersect_domain(const isl::union_set &uset) const;
+  inline isl::basic_map intersect_domain(const isl::point &bset) const;
+  inline isl::map intersect_domain_factor_domain(const isl::map &factor) const;
+  inline isl::union_map intersect_domain_factor_domain(const isl::union_map &factor) const;
+  inline isl::map intersect_domain_factor_range(const isl::map &factor) const;
+  inline isl::union_map intersect_domain_factor_range(const isl::union_map &factor) const;
+  inline isl::map intersect_params(const isl::set &params) const;
   inline isl::basic_map intersect_range(isl::basic_set bset) const;
+  inline isl::map intersect_range(const isl::set &set) const;
+  inline isl::union_map intersect_range(const isl::space &space) const;
+  inline isl::union_map intersect_range(const isl::union_set &uset) const;
+  inline isl::basic_map intersect_range(const isl::point &bset) const;
+  inline isl::map intersect_range_factor_domain(const isl::map &factor) const;
+  inline isl::union_map intersect_range_factor_domain(const isl::union_map &factor) const;
+  inline isl::map intersect_range_factor_range(const isl::map &factor) const;
+  inline isl::union_map intersect_range_factor_range(const isl::union_map &factor) const;
   inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline boolean is_disjoint(const isl::basic_map &bmap2) const;
+  inline boolean is_bijective() const;
+  inline boolean is_disjoint(const isl::map &map2) const;
+  inline boolean is_disjoint(const isl::union_map &umap2) const;
   inline boolean is_empty() const;
   inline boolean is_equal(const isl::basic_map &bmap2) const;
-  inline boolean is_rational() const;
+  inline boolean is_equal(const isl::map &map2) const;
+  inline boolean is_equal(const isl::union_map &umap2) const;
+  inline boolean is_injective() const;
   inline boolean is_single_valued() const;
-  inline boolean is_strict_subset(const isl::basic_map &bmap2) const;
+  inline boolean is_strict_subset(const isl::map &map2) const;
+  inline boolean is_strict_subset(const isl::union_map &umap2) const;
   inline boolean is_subset(const isl::basic_map &bmap2) const;
-  inline boolean is_universe() const;
-  static inline isl::basic_map less_at(isl::space space, unsigned int pos);
+  inline boolean is_subset(const isl::map &map2) const;
+  inline boolean is_subset(const isl::union_map &umap2) const;
+  inline boolean isa_map() const;
+  inline isl::map lex_ge_at(const isl::multi_pw_aff &mpa) const;
+  inline isl::map lex_gt_at(const isl::multi_pw_aff &mpa) const;
+  inline isl::map lex_le_at(const isl::multi_pw_aff &mpa) const;
+  inline isl::map lex_lt_at(const isl::multi_pw_aff &mpa) const;
   inline isl::map lexmax() const;
+  inline isl::pw_multi_aff lexmax_pw_multi_aff() 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 space, 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 isl_size n_constraint() const;
-  static inline isl::basic_map nat_universe(isl::space space);
-  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::map lower_bound(const isl::multi_pw_aff &lower) const;
+  inline isl::map lower_bound_si(isl::dim type, unsigned int pos, int value) const;
+  inline isl::map_list map_list() const;
+  inline isl::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
+  inline class size n_basic_map() 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 boolean plain_is_empty() const;
-  inline boolean plain_is_universe() 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;
-  inline isl::basic_map remove_divs() const;
-  inline isl::basic_map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::basic_map remove_redundancies() const;
+  inline isl::basic_map polyhedral_hull() const;
+  inline isl::map preimage_domain(const isl::multi_aff &ma) const;
+  inline isl::map preimage_domain(const isl::multi_pw_aff &mpa) const;
+  inline isl::map preimage_domain(const isl::pw_multi_aff &pma) const;
+  inline isl::union_map preimage_domain(const isl::union_pw_multi_aff &upma) const;
+  inline isl::map preimage_range(const isl::multi_aff &ma) const;
+  inline isl::map preimage_range(const isl::pw_multi_aff &pma) const;
+  inline isl::union_map preimage_range(const isl::union_pw_multi_aff &upma) const;
+  inline isl::map product(const isl::map &map2) const;
+  inline isl::union_map product(const isl::union_map &umap2) const;
+  inline isl::map project_out(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::map project_out_all_params() const;
+  inline isl::set range() const;
+  inline isl::map range_factor_domain() const;
+  inline isl::map range_factor_range() const;
+  inline isl::fixed_box range_lattice_tile() const;
+  inline isl::map range_map() const;
+  inline isl::map range_product(const isl::map &map2) const;
+  inline isl::union_map range_product(const isl::union_map &umap2) const;
+  inline isl::map range_reverse() const;
+  inline isl::fixed_box range_simple_fixed_box_hull() const;
+  inline class size range_tuple_dim() const;
+  inline isl::id range_tuple_id() const;
   inline isl::basic_map reverse() const;
   inline isl::basic_map sample() const;
-  inline isl::basic_map set_tuple_id(isl::dim type, isl::id id) const;
-  inline isl::basic_map set_tuple_name(isl::dim type, const std::string &s) const;
-  inline isl::basic_map sum(isl::basic_map bmap2) const;
-  inline isl::basic_map uncurry() const;
+  inline isl::map set_domain_tuple(const isl::id &id) const;
+  inline isl::map set_domain_tuple(const std::string &id) const;
+  inline isl::map set_range_tuple(const isl::id &id) const;
+  inline isl::map set_range_tuple(const std::string &id) const;
+  inline isl::map set_tuple_id(isl::dim type, const isl::id &id) const;
+  inline isl::map set_tuple_id(isl::dim type, const std::string &id) const;
+  inline isl::space space() const;
+  inline isl::map subtract(const isl::map &map2) const;
+  inline isl::union_map subtract(const isl::union_map &umap2) const;
+  inline isl::union_map subtract_domain(const isl::union_set &dom) const;
+  inline isl::union_map subtract_range(const isl::union_set &dom) const;
+  inline isl::map sum(const isl::map &map2) const;
+  inline isl::basic_map_list to_list() const;
+  inline isl::union_map to_union_map() const;
+  inline isl::id tuple_id(isl::dim type) const;
+  inline isl::map uncurry() const;
   inline isl::map unite(isl::basic_map bmap2) const;
+  inline isl::map unite(const isl::map &map2) const;
+  inline isl::union_map unite(const isl::union_map &umap2) const;
   static inline isl::basic_map universe(isl::space space);
-  inline isl::basic_map upper_bound_si(isl::dim type, unsigned int pos, int value) const;
-  inline isl::basic_set wrap() const;
-  inline isl::basic_map zip() const;
+  inline isl::basic_map unshifted_simple_hull() const;
+  inline isl::map upper_bound(const isl::multi_pw_aff &upper) const;
+  inline isl::map upper_bound_si(isl::dim type, unsigned int pos, int value) const;
+  inline isl::set wrap() const;
+  inline isl::map zip() const;
 };
 
 // declarations for isl::basic_map_list
 inline basic_map_list manage(__isl_take isl_basic_map_list *ptr);
 inline basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr);
 
 class basic_map_list {
   friend inline basic_map_list manage(__isl_take isl_basic_map_list *ptr);
   friend inline basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr);
 
+protected:
   isl_basic_map_list *ptr = nullptr;
 
   inline explicit basic_map_list(__isl_take isl_basic_map_list *ptr);
 
 public:
   inline /* implicit */ basic_map_list();
   inline /* implicit */ basic_map_list(const basic_map_list &obj);
+  inline explicit basic_map_list(isl::ctx ctx, int n);
+  inline explicit basic_map_list(isl::basic_map el);
   inline basic_map_list &operator=(basic_map_list obj);
   inline ~basic_map_list();
   inline __isl_give isl_basic_map_list *copy() const &;
   inline __isl_give isl_basic_map_list *copy() && = delete;
   inline __isl_keep isl_basic_map_list *get() const;
   inline __isl_give isl_basic_map_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::basic_map_list add(isl::basic_map el) const;
-  static inline isl::basic_map_list alloc(isl::ctx ctx, int n);
+  inline isl::basic_map at(int index) const;
+  inline isl::basic_map get_at(int index) const;
   inline isl::basic_map_list clear() const;
   inline isl::basic_map_list concat(isl::basic_map_list list2) const;
   inline isl::basic_map_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(basic_map)> &fn) const;
-  static inline isl::basic_map_list from_basic_map(isl::basic_map el);
-  inline isl::basic_map get_at(int index) const;
-  inline isl::basic_map get_basic_map(int index) const;
+  inline stat foreach(const std::function<stat(isl::basic_map)> &fn) const;
   inline isl::basic_map_list insert(unsigned int pos, isl::basic_map el) const;
-  inline isl_size n_basic_map() const;
-  inline isl::basic_map_list reverse() const;
-  inline isl::basic_map_list set_basic_map(int index, isl::basic_map el) const;
-  inline isl_size size() const;
-  inline isl::basic_map_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
 };
 
 // declarations for isl::basic_set
 inline basic_set manage(__isl_take isl_basic_set *ptr);
 inline basic_set manage_copy(__isl_keep isl_basic_set *ptr);
 
 class basic_set {
   friend inline basic_set manage(__isl_take isl_basic_set *ptr);
   friend inline basic_set manage_copy(__isl_keep isl_basic_set *ptr);
 
+protected:
   isl_basic_set *ptr = nullptr;
 
   inline explicit basic_set(__isl_take isl_basic_set *ptr);
 
 public:
   inline /* implicit */ basic_set();
   inline /* implicit */ basic_set(const basic_set &obj);
   inline /* implicit */ basic_set(isl::point pnt);
   inline explicit basic_set(isl::ctx ctx, const std::string &str);
   inline basic_set &operator=(basic_set obj);
   inline ~basic_set();
   inline __isl_give isl_basic_set *copy() const &;
   inline __isl_give isl_basic_set *copy() && = delete;
   inline __isl_keep isl_basic_set *get() const;
   inline __isl_give isl_basic_set *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
+  inline isl::set add_constraint(const isl::constraint &constraint) const;
+  inline isl::set add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_set affine_hull() const;
-  inline isl::basic_set align_params(isl::space model) const;
+  inline isl::set align_params(const isl::space &model) const;
   inline isl::basic_set apply(isl::basic_map bmap) const;
-  static inline isl::basic_set box_from_points(isl::point pnt1, isl::point pnt2);
-  inline isl::basic_set coefficients() const;
+  inline isl::set apply(const isl::map &map) const;
+  inline isl::union_set apply(const isl::union_map &umap) const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::basic_set_list basic_set_list() const;
+  inline isl::set bind(const isl::multi_id &tuple) const;
+  inline isl::set coalesce() const;
+  inline isl::set complement() const;
+  inline isl::union_set compute_divs() const;
+  inline boolean contains(const isl::space &space) const;
+  inline isl::basic_set convex_hull() const;
   inline isl::basic_set detect_equalities() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
+  inline boolean dim_has_any_lower_bound(isl::dim type, unsigned int pos) const;
+  inline isl::id dim_id(isl::dim type, unsigned int pos) const;
+  inline isl::pw_aff dim_max(int pos) const;
   inline isl::val dim_max_val(int pos) const;
-  inline isl::basic_set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  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::mat equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const;
+  inline isl::pw_aff dim_min(int pos) const;
+  inline isl::val dim_min_val(int pos) const;
+  inline std::string dim_name(isl::dim type, unsigned int pos) const;
+  inline isl::aff div(int pos) const;
+  inline isl::aff get_div(int pos) const;
+  inline isl::set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::set eliminate(isl::dim type, unsigned int first, unsigned int n) const;
+  inline boolean every_set(const std::function<boolean(isl::set)> &test) const;
+  inline isl::set extract_set(const isl::space &space) const;
+  inline int find_dim_by_id(isl::dim type, const isl::id &id) const;
+  inline int find_dim_by_id(isl::dim type, const std::string &id) const;
   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 fix_val(isl::dim type, unsigned int pos, long v) const;
   inline isl::basic_set flatten() const;
-  inline stat foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<stat(constraint, constraint, basic_set)> &fn) const;
-  inline stat foreach_constraint(const std::function<stat(constraint)> &fn) const;
-  static inline isl::basic_set from_constraint(isl::constraint constraint);
-  static inline isl::basic_set from_multi_aff(isl::multi_aff ma);
-  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 stat foreach_basic_set(const std::function<stat(isl::basic_set)> &fn) const;
+  inline stat foreach_point(const std::function<stat(isl::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::set)> &fn) const;
   inline isl::basic_set gist(isl::basic_set context) const;
-  inline isl::mat inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const;
-  inline isl::basic_set insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
+  inline isl::set gist(const isl::set &context) const;
+  inline isl::union_set gist(const isl::union_set &context) const;
+  inline isl::basic_set gist(const isl::point &context) const;
+  inline isl::set gist_params(const isl::set &context) const;
+  inline boolean has_equal_space(const isl::set &set2) const;
+  inline isl::map identity() const;
+  inline isl::union_pw_multi_aff identity_union_pw_multi_aff() 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::map insert_domain(const isl::space &domain) const;
   inline isl::basic_set intersect(isl::basic_set bset2) const;
+  inline isl::set intersect(const isl::set &set2) const;
+  inline isl::union_set intersect(const isl::union_set &uset2) const;
+  inline isl::basic_set intersect(const isl::point &bset2) const;
   inline isl::basic_set intersect_params(isl::basic_set bset2) const;
+  inline isl::set intersect_params(const isl::set &params) const;
+  inline isl::basic_set intersect_params(const isl::point &bset2) const;
   inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline boolean involves_locals() const;
   inline boolean is_bounded() const;
-  inline boolean is_disjoint(const isl::basic_set &bset2) const;
+  inline boolean is_disjoint(const isl::set &set2) const;
+  inline boolean is_disjoint(const isl::union_set &uset2) const;
   inline boolean is_empty() const;
   inline boolean is_equal(const isl::basic_set &bset2) const;
-  inline int is_rational() const;
+  inline boolean is_equal(const isl::set &set2) const;
+  inline boolean is_equal(const isl::union_set &uset2) const;
+  inline boolean is_equal(const isl::point &bset2) const;
+  inline boolean is_params() const;
+  inline boolean is_singleton() const;
+  inline boolean is_strict_subset(const isl::set &set2) const;
+  inline boolean is_strict_subset(const isl::union_set &uset2) const;
   inline boolean is_subset(const isl::basic_set &bset2) const;
-  inline boolean is_universe() const;
+  inline boolean is_subset(const isl::set &set2) const;
+  inline boolean is_subset(const isl::union_set &uset2) const;
+  inline boolean is_subset(const isl::point &bset2) const;
   inline boolean is_wrapping() const;
+  inline boolean isa_set() const;
   inline isl::set lexmax() const;
+  inline isl::pw_multi_aff lexmax_pw_multi_aff() 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::pw_multi_aff lexmin_pw_multi_aff() const;
+  inline isl::set lower_bound(const isl::multi_pw_aff &lower) const;
+  inline isl::set lower_bound(const isl::multi_val &lower) 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, const isl::val &value) const;
+  inline isl::set lower_bound_val(isl::dim type, unsigned int pos, long value) const;
+  inline isl::multi_pw_aff max_multi_pw_aff() 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 isl_size n_constraint() const;
-  inline isl_size n_dim() const;
-  static inline isl::basic_set nat_universe(isl::space space);
-  inline isl::basic_set neg() const;
+  inline isl::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::val min_val(const isl::aff &obj) const;
+  inline class size n_basic_set() const;
   inline isl::basic_set params() const;
-  inline boolean plain_is_empty() const;
-  inline boolean plain_is_equal(const isl::basic_set &bset2) const;
-  inline boolean plain_is_universe() 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::val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
+  inline isl::multi_val plain_multi_val_if_fixed() const;
+  inline isl::basic_set polyhedral_hull() const;
+  inline isl::set preimage(const isl::multi_aff &ma) const;
+  inline isl::set preimage(const isl::multi_pw_aff &mpa) const;
+  inline isl::set preimage(const isl::pw_multi_aff &pma) const;
+  inline isl::union_set preimage(const isl::union_pw_multi_aff &upma) const;
+  inline isl::set product(const isl::set &set2) const;
   inline isl::basic_set project_out(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::mat reduced_basis() 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;
+  inline isl::set project_out_all_params() const;
+  inline isl::set project_out_param(const isl::id &id) const;
+  inline isl::set project_out_param(const std::string &id) const;
+  inline isl::set project_out_param(const isl::id_list &list) const;
+  inline isl::pw_multi_aff pw_multi_aff_on_domain(const isl::multi_val &mv) const;
+  inline isl::set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::set remove_divs() const;
+  inline isl::set remove_redundancies() const;
+  inline isl::set reset_tuple_id() const;
   inline isl::basic_set sample() const;
   inline isl::point sample_point() const;
-  inline isl::basic_set set_tuple_id(isl::id id) const;
-  inline isl::basic_set set_tuple_name(const std::string &s) const;
-  inline isl::basic_set solutions() const;
+  inline isl::set set_dim_id(isl::dim type, unsigned int pos, const isl::id &id) const;
+  inline isl::set set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const;
+  inline isl::set_list set_list() const;
+  inline isl::set set_tuple_id(const isl::id &id) const;
+  inline isl::set set_tuple_id(const std::string &id) const;
+  inline isl::fixed_box simple_fixed_box_hull() const;
+  inline isl::basic_set simple_hull() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
+  inline isl::val stride(int pos) const;
+  inline isl::set subtract(const isl::set &set2) const;
+  inline isl::union_set subtract(const isl::union_set &uset2) const;
+  inline isl::basic_set_list to_list() const;
+  inline isl::set to_set() const;
+  inline isl::union_set to_union_set() const;
+  inline isl::map translation() const;
+  inline class size tuple_dim() const;
+  inline isl::id tuple_id() const;
+  inline std::string tuple_name() const;
+  inline isl::set unbind_params(const isl::multi_id &tuple) const;
+  inline isl::map unbind_params_insert_domain(const isl::multi_id &domain) const;
   inline isl::set unite(isl::basic_set bset2) const;
+  inline isl::set unite(const isl::set &set2) const;
+  inline isl::union_set unite(const isl::union_set &uset2) const;
+  inline isl::set unite(const isl::point &bset2) const;
   static inline isl::basic_set universe(isl::space space);
-  inline isl::basic_map unwrap() const;
-  inline isl::basic_set upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const;
+  inline isl::basic_set unshifted_simple_hull() const;
+  inline isl::map unwrap() const;
+  inline isl::set upper_bound(const isl::multi_pw_aff &upper) const;
+  inline isl::set upper_bound(const isl::multi_val &upper) const;
+  inline isl::set upper_bound_val(isl::dim type, unsigned int pos, const isl::val &value) const;
+  inline isl::set upper_bound_val(isl::dim type, unsigned int pos, long value) const;
 };
 
 // declarations for isl::basic_set_list
 inline basic_set_list manage(__isl_take isl_basic_set_list *ptr);
 inline basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr);
 
 class basic_set_list {
   friend inline basic_set_list manage(__isl_take isl_basic_set_list *ptr);
   friend inline basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr);
 
+protected:
   isl_basic_set_list *ptr = nullptr;
 
   inline explicit basic_set_list(__isl_take isl_basic_set_list *ptr);
 
 public:
   inline /* implicit */ basic_set_list();
   inline /* implicit */ basic_set_list(const basic_set_list &obj);
+  inline explicit basic_set_list(isl::ctx ctx, int n);
+  inline explicit basic_set_list(isl::basic_set el);
   inline basic_set_list &operator=(basic_set_list obj);
   inline ~basic_set_list();
   inline __isl_give isl_basic_set_list *copy() const &;
   inline __isl_give isl_basic_set_list *copy() && = delete;
   inline __isl_keep isl_basic_set_list *get() const;
   inline __isl_give isl_basic_set_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::basic_set_list add(isl::basic_set el) const;
-  static inline isl::basic_set_list alloc(isl::ctx ctx, int n);
+  inline isl::basic_set at(int index) const;
+  inline isl::basic_set get_at(int index) const;
   inline isl::basic_set_list clear() const;
-  inline isl::basic_set_list coefficients() const;
   inline isl::basic_set_list concat(isl::basic_set_list list2) const;
   inline isl::basic_set_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(basic_set)> &fn) const;
-  static inline isl::basic_set_list from_basic_set(isl::basic_set el);
-  inline isl::basic_set get_at(int index) const;
-  inline isl::basic_set get_basic_set(int index) const;
+  inline stat foreach(const std::function<stat(isl::basic_set)> &fn) const;
   inline isl::basic_set_list insert(unsigned int pos, isl::basic_set el) const;
-  inline isl_size n_basic_set() const;
-  inline isl::basic_set_list reverse() const;
-  inline isl::basic_set_list set_basic_set(int index, isl::basic_set el) const;
-  inline isl_size size() const;
-  inline isl::basic_set_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
 };
 
 // declarations for isl::constraint
 inline constraint manage(__isl_take isl_constraint *ptr);
 inline constraint manage_copy(__isl_keep isl_constraint *ptr);
 
 class constraint {
   friend inline constraint manage(__isl_take isl_constraint *ptr);
   friend inline constraint manage_copy(__isl_keep isl_constraint *ptr);
 
+protected:
   isl_constraint *ptr = nullptr;
 
   inline explicit constraint(__isl_take isl_constraint *ptr);
 
 public:
   inline /* implicit */ constraint();
   inline /* implicit */ constraint(const constraint &obj);
   inline constraint &operator=(constraint obj);
   inline ~constraint();
   inline __isl_give isl_constraint *copy() const &;
   inline __isl_give isl_constraint *copy() && = delete;
   inline __isl_keep isl_constraint *get() const;
   inline __isl_give isl_constraint *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   static inline isl::constraint alloc_equality(isl::local_space ls);
   static inline isl::constraint alloc_inequality(isl::local_space ls);
-  inline int cmp_last_non_zero(const isl::constraint &c2) const;
-  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 boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline boolean is_div_constraint() const;
-  inline boolean is_lower_bound(isl::dim type, unsigned int pos) const;
-  inline boolean is_upper_bound(isl::dim type, unsigned int pos) 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
-inline constraint_list manage(__isl_take isl_constraint_list *ptr);
-inline constraint_list manage_copy(__isl_keep isl_constraint_list *ptr);
-
-class constraint_list {
-  friend inline constraint_list manage(__isl_take isl_constraint_list *ptr);
-  friend inline constraint_list manage_copy(__isl_keep isl_constraint_list *ptr);
-
-  isl_constraint_list *ptr = nullptr;
-
-  inline explicit constraint_list(__isl_take isl_constraint_list *ptr);
-
-public:
-  inline /* implicit */ constraint_list();
-  inline /* implicit */ constraint_list(const constraint_list &obj);
-  inline constraint_list &operator=(constraint_list obj);
-  inline ~constraint_list();
-  inline __isl_give isl_constraint_list *copy() const &;
-  inline __isl_give isl_constraint_list *copy() && = delete;
-  inline __isl_keep isl_constraint_list *get() const;
-  inline __isl_give isl_constraint_list *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::constraint_list add(isl::constraint el) const;
-  static inline isl::constraint_list alloc(isl::ctx ctx, int n);
-  inline isl::constraint_list clear() const;
-  inline isl::constraint_list concat(isl::constraint_list list2) const;
-  inline isl::constraint_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(constraint)> &fn) const;
-  static inline isl::constraint_list from_constraint(isl::constraint el);
-  inline isl::constraint get_at(int index) const;
-  inline isl::constraint get_constraint(int index) const;
-  inline isl::constraint_list insert(unsigned int pos, isl::constraint el) const;
-  inline isl_size n_constraint() const;
-  inline isl::constraint_list reverse() const;
-  inline isl::constraint_list set_constraint(int index, isl::constraint el) const;
-  inline isl_size size() const;
-  inline isl::constraint_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline isl::constraint set_constant_val(long v) const;
 };
 
 // declarations for isl::fixed_box
 inline fixed_box manage(__isl_take isl_fixed_box *ptr);
 inline fixed_box manage_copy(__isl_keep isl_fixed_box *ptr);
 
 class fixed_box {
   friend inline fixed_box manage(__isl_take isl_fixed_box *ptr);
   friend inline fixed_box manage_copy(__isl_keep isl_fixed_box *ptr);
 
+protected:
   isl_fixed_box *ptr = nullptr;
 
   inline explicit fixed_box(__isl_take isl_fixed_box *ptr);
 
 public:
   inline /* implicit */ fixed_box();
   inline /* implicit */ fixed_box(const fixed_box &obj);
   inline fixed_box &operator=(fixed_box obj);
   inline ~fixed_box();
   inline __isl_give isl_fixed_box *copy() const &;
   inline __isl_give isl_fixed_box *copy() && = delete;
   inline __isl_keep isl_fixed_box *get() const;
   inline __isl_give isl_fixed_box *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
+  inline boolean is_valid() const;
+  inline isl::multi_aff offset() const;
   inline isl::multi_aff get_offset() const;
+  inline isl::multi_val size() const;
   inline isl::multi_val get_size() const;
+  inline isl::space space() const;
   inline isl::space get_space() const;
-  inline boolean is_valid() const;
 };
 
 // declarations for isl::id
 inline id manage(__isl_take isl_id *ptr);
 inline id manage_copy(__isl_keep isl_id *ptr);
 
 class id {
   friend inline id manage(__isl_take isl_id *ptr);
   friend inline id manage_copy(__isl_keep isl_id *ptr);
 
+protected:
   isl_id *ptr = nullptr;
 
   inline explicit id(__isl_take isl_id *ptr);
 
 public:
   inline /* implicit */ id();
   inline /* implicit */ id(const id &obj);
   inline explicit id(isl::ctx ctx, const std::string &str);
   inline id &operator=(id obj);
   inline ~id();
   inline __isl_give isl_id *copy() const &;
   inline __isl_give isl_id *copy() && = delete;
   inline __isl_keep isl_id *get() const;
   inline __isl_give isl_id *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   static inline isl::id alloc(isl::ctx ctx, const std::string &name, void * user);
-  inline uint32_t get_hash() const;
+  inline std::string name() const;
   inline std::string get_name() const;
+  inline isl::id_list to_list() const;
+  inline void * user() const;
   inline void * get_user() const;
 };
 
 // declarations for isl::id_list
 inline id_list manage(__isl_take isl_id_list *ptr);
 inline id_list manage_copy(__isl_keep isl_id_list *ptr);
 
 class id_list {
   friend inline id_list manage(__isl_take isl_id_list *ptr);
   friend inline id_list manage_copy(__isl_keep isl_id_list *ptr);
 
+protected:
   isl_id_list *ptr = nullptr;
 
   inline explicit id_list(__isl_take isl_id_list *ptr);
 
 public:
   inline /* implicit */ id_list();
   inline /* implicit */ id_list(const id_list &obj);
+  inline explicit id_list(isl::ctx ctx, int n);
+  inline explicit id_list(isl::id el);
+  inline explicit id_list(isl::ctx ctx, const std::string &str);
   inline id_list &operator=(id_list obj);
   inline ~id_list();
   inline __isl_give isl_id_list *copy() const &;
   inline __isl_give isl_id_list *copy() && = delete;
   inline __isl_keep isl_id_list *get() const;
   inline __isl_give isl_id_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::id_list add(isl::id el) const;
-  static inline isl::id_list alloc(isl::ctx ctx, int n);
+  inline isl::id_list add(const std::string &el) const;
+  inline isl::id at(int index) const;
+  inline isl::id get_at(int index) const;
   inline isl::id_list clear() const;
   inline isl::id_list concat(isl::id_list list2) const;
   inline isl::id_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(id)> &fn) const;
-  static inline isl::id_list from_id(isl::id el);
-  inline isl::id get_at(int index) const;
-  inline isl::id get_id(int index) const;
+  inline stat foreach(const std::function<stat(isl::id)> &fn) const;
   inline isl::id_list insert(unsigned int pos, isl::id el) const;
-  inline isl_size n_id() const;
-  inline isl::id_list reverse() const;
-  inline isl::id_list set_id(int index, isl::id el) const;
-  inline isl_size size() const;
-  inline isl::id_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline isl::id_list insert(unsigned int pos, const std::string &el) const;
+  inline class size size() const;
 };
 
 // declarations for isl::id_to_ast_expr
 inline id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);
 inline id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr);
 
 class id_to_ast_expr {
   friend inline id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);
   friend inline id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr);
 
+protected:
   isl_id_to_ast_expr *ptr = nullptr;
 
   inline explicit id_to_ast_expr(__isl_take isl_id_to_ast_expr *ptr);
 
 public:
   inline /* implicit */ id_to_ast_expr();
   inline /* implicit */ id_to_ast_expr(const id_to_ast_expr &obj);
   inline id_to_ast_expr &operator=(id_to_ast_expr obj);
   inline ~id_to_ast_expr();
   inline __isl_give isl_id_to_ast_expr *copy() const &;
   inline __isl_give isl_id_to_ast_expr *copy() && = delete;
   inline __isl_keep isl_id_to_ast_expr *get() const;
   inline __isl_give isl_id_to_ast_expr *release();
   inline bool is_null() const;
   inline isl::ctx 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 stat foreach(const std::function<stat(id, ast_expr)> &fn) const;
-  inline isl::ast_expr get(isl::id key) const;
-  inline boolean has(const isl::id &key) const;
   inline isl::id_to_ast_expr set(isl::id key, isl::ast_expr val) const;
+  inline isl::id_to_ast_expr set(const std::string &key, const isl::ast_expr &val) const;
 };
 
 // declarations for isl::local_space
 inline local_space manage(__isl_take isl_local_space *ptr);
 inline local_space manage_copy(__isl_keep isl_local_space *ptr);
 
 class local_space {
   friend inline local_space manage(__isl_take isl_local_space *ptr);
   friend inline local_space manage_copy(__isl_keep isl_local_space *ptr);
 
+protected:
   isl_local_space *ptr = nullptr;
 
   inline explicit local_space(__isl_take isl_local_space *ptr);
 
 public:
   inline /* implicit */ local_space();
   inline /* implicit */ local_space(const local_space &obj);
   inline explicit local_space(isl::space space);
   inline local_space &operator=(local_space obj);
   inline ~local_space();
   inline __isl_give isl_local_space *copy() const &;
   inline __isl_give isl_local_space *copy() && = delete;
   inline __isl_keep isl_local_space *get() const;
   inline __isl_give isl_local_space *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::local_space add_dims(isl::dim type, unsigned int n) const;
-  inline isl_size dim(isl::dim type) const;
-  inline isl::local_space domain() const;
-  inline isl::local_space drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  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 boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline boolean has_dim_name(isl::dim type, unsigned int pos) 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 boolean is_equal(const isl::local_space &ls2) const;
-  inline boolean is_params() const;
-  inline boolean is_set() 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
 inline map manage(__isl_take isl_map *ptr);
 inline map manage_copy(__isl_keep isl_map *ptr);
 
 class map {
   friend inline map manage(__isl_take isl_map *ptr);
   friend inline map manage_copy(__isl_keep isl_map *ptr);
 
+protected:
   isl_map *ptr = nullptr;
 
   inline explicit map(__isl_take isl_map *ptr);
 
 public:
   inline /* implicit */ map();
   inline /* implicit */ map(const map &obj);
   inline /* implicit */ map(isl::basic_map bmap);
   inline explicit map(isl::ctx ctx, const std::string &str);
   inline map &operator=(map obj);
   inline ~map();
   inline __isl_give isl_map *copy() const &;
   inline __isl_give isl_map *copy() && = delete;
   inline __isl_keep isl_map *get() const;
   inline __isl_give isl_map *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  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::union_map apply_domain(const isl::union_map &umap2) const;
+  inline isl::map apply_domain(const isl::basic_map &map2) const;
   inline isl::map apply_range(isl::map map2) const;
+  inline isl::union_map apply_range(const isl::union_map &umap2) const;
+  inline isl::map apply_range(const isl::basic_map &map2) const;
+  inline isl::map as_map() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::union_pw_multi_aff as_union_pw_multi_aff() const;
+  inline isl::basic_map_list basic_map_list() const;
+  inline isl::basic_map_list get_basic_map_list() const;
   inline isl::set bind_domain(isl::multi_id tuple) const;
   inline isl::set bind_range(isl::multi_id tuple) const;
   inline boolean can_curry() const;
-  inline boolean can_range_curry() const;
-  inline boolean can_uncurry() const;
-  inline boolean can_zip() const;
   inline isl::map coalesce() const;
   inline isl::map complement() const;
-  inline isl::basic_map convex_hull() const;
+  inline isl::union_map compute_divs() const;
   inline isl::map curry() const;
   inline isl::set deltas() const;
-  inline isl::map deltas_map() const;
   inline isl::map detect_equalities() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size 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 boolean domain_is_wrapping() const;
   inline isl::map domain_map() const;
+  inline isl::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
   inline isl::map domain_product(isl::map map2) const;
-  inline isl_size domain_tuple_dim() 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;
+  inline isl::union_map domain_product(const isl::union_map &umap2) const;
+  inline isl::map domain_product(const isl::basic_map &map2) const;
+  inline class size domain_tuple_dim() const;
+  inline isl::id domain_tuple_id() const;
+  inline isl::id get_domain_tuple_id() const;
   static inline isl::map empty(isl::space space);
   inline isl::map eq_at(isl::multi_pw_aff mpa) const;
+  inline isl::union_map eq_at(const isl::multi_union_pw_aff &mupa) const;
+  inline isl::map eq_at(const isl::aff &mpa) const;
+  inline isl::map eq_at(const isl::multi_aff &mpa) const;
+  inline isl::map eq_at(const isl::pw_aff &mpa) const;
+  inline isl::map eq_at(const isl::pw_multi_aff &mpa) const;
   inline isl::map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
+  inline boolean every_map(const std::function<boolean(isl::map)> &test) const;
+  inline isl::map extract_map(const isl::space &space) 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::union_map fixed_power(const isl::val &exp) const;
+  inline isl::union_map fixed_power(long exp) const;
   inline isl::map flat_range_product(isl::map map2) const;
+  inline isl::union_map flat_range_product(const isl::union_map &umap2) const;
+  inline isl::map flat_range_product(const isl::basic_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 stat foreach_basic_map(const std::function<stat(basic_map)> &fn) const;
+  inline isl::map floordiv_val(long d) const;
+  inline stat foreach_basic_map(const std::function<stat(isl::basic_map)> &fn) const;
+  inline stat foreach_map(const std::function<stat(isl::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::basic_map_list get_basic_map_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 uint32_t get_hash() const;
-  inline isl::fixed_box get_range_simple_fixed_box_hull() 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::union_map gist(const isl::union_map &context) const;
+  inline isl::map gist(const isl::basic_map &context) const;
   inline isl::map gist_domain(isl::set context) const;
+  inline isl::union_map gist_domain(const isl::union_set &uset) const;
+  inline isl::map gist_domain(const isl::basic_set &context) const;
+  inline isl::map gist_domain(const isl::point &context) const;
   inline isl::map gist_params(isl::set context) const;
-  inline isl::map gist_range(isl::set context) const;
-  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
+  inline isl::union_map gist_range(const isl::union_set &uset) const;
+  inline boolean has_domain_tuple_id() const;
   inline boolean has_equal_space(const isl::map &map2) const;
+  inline boolean has_range_tuple_id() const;
   inline boolean has_tuple_id(isl::dim type) const;
   inline boolean has_tuple_name(isl::dim type) const;
   static inline isl::map identity(isl::space space);
-  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::union_map intersect(const isl::union_map &umap2) const;
+  inline isl::map intersect(const isl::basic_map &map2) const;
   inline isl::map intersect_domain(isl::set set) const;
+  inline isl::union_map intersect_domain(const isl::space &space) const;
+  inline isl::union_map intersect_domain(const isl::union_set &uset) const;
+  inline isl::map intersect_domain(const isl::basic_set &set) const;
+  inline isl::map intersect_domain(const isl::point &set) const;
   inline isl::map intersect_domain_factor_domain(isl::map factor) const;
+  inline isl::union_map intersect_domain_factor_domain(const isl::union_map &factor) const;
+  inline isl::map intersect_domain_factor_domain(const isl::basic_map &factor) const;
   inline isl::map intersect_domain_factor_range(isl::map factor) const;
+  inline isl::union_map intersect_domain_factor_range(const isl::union_map &factor) const;
+  inline isl::map intersect_domain_factor_range(const isl::basic_map &factor) const;
   inline isl::map intersect_params(isl::set params) const;
   inline isl::map intersect_range(isl::set set) const;
+  inline isl::union_map intersect_range(const isl::space &space) const;
+  inline isl::union_map intersect_range(const isl::union_set &uset) const;
+  inline isl::map intersect_range(const isl::basic_set &set) const;
+  inline isl::map intersect_range(const isl::point &set) const;
   inline isl::map intersect_range_factor_domain(isl::map factor) const;
+  inline isl::union_map intersect_range_factor_domain(const isl::union_map &factor) const;
+  inline isl::map intersect_range_factor_domain(const isl::basic_map &factor) const;
   inline isl::map intersect_range_factor_range(isl::map factor) const;
+  inline isl::union_map intersect_range_factor_range(const isl::union_map &factor) const;
+  inline isl::map intersect_range_factor_range(const isl::basic_map &factor) const;
   inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline boolean is_bijective() const;
   inline boolean is_disjoint(const isl::map &map2) const;
+  inline boolean is_disjoint(const isl::union_map &umap2) const;
+  inline boolean is_disjoint(const isl::basic_map &map2) const;
   inline boolean is_empty() const;
   inline boolean is_equal(const isl::map &map2) const;
-  inline boolean is_identity() const;
+  inline boolean is_equal(const isl::union_map &umap2) const;
+  inline boolean is_equal(const isl::basic_map &map2) const;
   inline boolean is_injective() const;
-  inline boolean is_product() const;
   inline boolean is_single_valued() const;
   inline boolean is_strict_subset(const isl::map &map2) const;
+  inline boolean is_strict_subset(const isl::union_map &umap2) const;
+  inline boolean is_strict_subset(const isl::basic_map &map2) const;
   inline boolean is_subset(const isl::map &map2) const;
-  inline int is_translation() const;
+  inline boolean is_subset(const isl::union_map &umap2) const;
+  inline boolean is_subset(const isl::basic_map &map2) const;
+  inline boolean isa_map() const;
   static inline isl::map lex_ge(isl::space set_space);
   inline isl::map lex_ge_at(isl::multi_pw_aff mpa) const;
-  static inline isl::map lex_ge_first(isl::space space, unsigned int n);
-  inline isl::map lex_ge_map(isl::map map2) const;
   static inline isl::map lex_gt(isl::space set_space);
   inline isl::map lex_gt_at(isl::multi_pw_aff mpa) const;
-  static inline isl::map lex_gt_first(isl::space space, unsigned int n);
-  inline isl::map lex_gt_map(isl::map map2) const;
   static inline isl::map lex_le(isl::space set_space);
   inline isl::map lex_le_at(isl::multi_pw_aff mpa) const;
-  static inline isl::map lex_le_first(isl::space space, unsigned int n);
-  inline isl::map lex_le_map(isl::map map2) const;
   static inline isl::map lex_lt(isl::space set_space);
   inline isl::map lex_lt_at(isl::multi_pw_aff mpa) const;
-  static inline isl::map lex_lt_first(isl::space space, unsigned int n);
-  inline isl::map lex_lt_map(isl::map map2) const;
   inline isl::map lexmax() const;
   inline isl::pw_multi_aff lexmax_pw_multi_aff() const;
   inline isl::map lexmin() const;
   inline isl::pw_multi_aff lexmin_pw_multi_aff() const;
   inline isl::map lower_bound(isl::multi_pw_aff lower) const;
   inline isl::map lower_bound_si(isl::dim type, unsigned int pos, int value) const;
-  inline isl::map lower_bound_val(isl::dim type, unsigned int pos, isl::val value) const;
+  inline isl::map_list map_list() const;
   inline isl::multi_pw_aff max_multi_pw_aff() const;
   inline isl::multi_pw_aff min_multi_pw_aff() const;
   inline isl::map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
-  inline isl_size n_basic_map() const;
-  static inline isl::map nat_universe(isl::space space);
-  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 class size n_basic_map() 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 boolean plain_is_empty() const;
-  inline boolean plain_is_equal(const isl::map &map2) const;
-  inline boolean plain_is_injective() const;
-  inline boolean plain_is_single_valued() const;
-  inline boolean plain_is_universe() const;
-  inline isl::basic_map plain_unshifted_simple_hull() const;
   inline isl::basic_map polyhedral_hull() const;
   inline isl::map preimage_domain(isl::multi_aff ma) const;
   inline isl::map preimage_domain(isl::multi_pw_aff mpa) const;
   inline isl::map preimage_domain(isl::pw_multi_aff pma) const;
+  inline isl::union_map preimage_domain(const isl::union_pw_multi_aff &upma) const;
   inline isl::map preimage_range(isl::multi_aff ma) const;
   inline isl::map preimage_range(isl::pw_multi_aff pma) const;
+  inline isl::union_map preimage_range(const isl::union_pw_multi_aff &upma) const;
   inline isl::map product(isl::map map2) const;
+  inline isl::union_map product(const isl::union_map &umap2) const;
+  inline isl::map product(const isl::basic_map &map2) const;
   inline isl::map project_out(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::map project_out_all_params() 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 boolean range_is_wrapping() const;
+  inline isl::fixed_box range_lattice_tile() const;
+  inline isl::fixed_box get_range_lattice_tile() const;
   inline isl::map range_map() const;
   inline isl::map range_product(isl::map map2) const;
+  inline isl::union_map range_product(const isl::union_map &umap2) const;
+  inline isl::map range_product(const isl::basic_map &map2) const;
   inline isl::map range_reverse() const;
-  inline isl_size range_tuple_dim() 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;
-  inline isl::map reset_user() const;
+  inline isl::fixed_box range_simple_fixed_box_hull() const;
+  inline isl::fixed_box get_range_simple_fixed_box_hull() const;
+  inline class size range_tuple_dim() const;
+  inline isl::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
   inline isl::map reverse() const;
   inline isl::basic_map sample() const;
-  inline isl::map set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
+  inline isl::map set_domain_tuple(isl::id id) const;
+  inline isl::map set_domain_tuple(const std::string &id) const;
+  inline isl::map set_range_tuple(isl::id id) const;
+  inline isl::map set_range_tuple(const std::string &id) const;
   inline isl::map set_tuple_id(isl::dim type, isl::id id) const;
-  inline isl::map set_tuple_name(isl::dim type, const std::string &s) const;
-  inline isl::basic_map simple_hull() const;
+  inline isl::map set_tuple_id(isl::dim type, const std::string &id) const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::map subtract(isl::map map2) const;
-  inline isl::map subtract_domain(isl::set dom) const;
-  inline isl::map subtract_range(isl::set dom) const;
+  inline isl::union_map subtract(const isl::union_map &umap2) const;
+  inline isl::map subtract(const isl::basic_map &map2) const;
+  inline isl::union_map subtract_domain(const isl::union_set &dom) const;
+  inline isl::union_map subtract_range(const isl::union_set &dom) const;
   inline isl::map sum(isl::map map2) const;
+  inline isl::map_list to_list() const;
+  inline isl::union_map to_union_map() const;
+  inline isl::id tuple_id(isl::dim type) const;
+  inline isl::id get_tuple_id(isl::dim type) const;
   inline isl::map uncurry() const;
   inline isl::map unite(isl::map map2) const;
+  inline isl::union_map unite(const isl::union_map &umap2) const;
+  inline isl::map unite(const isl::basic_map &map2) const;
   static inline isl::map universe(isl::space space);
   inline isl::basic_map unshifted_simple_hull() const;
-  inline isl::basic_map unshifted_simple_hull_from_map_list(isl::map_list list) const;
   inline isl::map upper_bound(isl::multi_pw_aff upper) const;
   inline isl::map upper_bound_si(isl::dim type, unsigned int pos, int value) const;
-  inline isl::map upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const;
   inline isl::set wrap() const;
   inline isl::map zip() const;
 };
 
 // declarations for isl::map_list
 inline map_list manage(__isl_take isl_map_list *ptr);
 inline map_list manage_copy(__isl_keep isl_map_list *ptr);
 
 class map_list {
   friend inline map_list manage(__isl_take isl_map_list *ptr);
   friend inline map_list manage_copy(__isl_keep isl_map_list *ptr);
 
+protected:
   isl_map_list *ptr = nullptr;
 
   inline explicit map_list(__isl_take isl_map_list *ptr);
 
 public:
   inline /* implicit */ map_list();
   inline /* implicit */ map_list(const map_list &obj);
+  inline explicit map_list(isl::ctx ctx, int n);
+  inline explicit map_list(isl::map el);
+  inline explicit map_list(isl::ctx ctx, const std::string &str);
   inline map_list &operator=(map_list obj);
   inline ~map_list();
   inline __isl_give isl_map_list *copy() const &;
   inline __isl_give isl_map_list *copy() && = delete;
   inline __isl_keep isl_map_list *get() const;
   inline __isl_give isl_map_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::map_list add(isl::map el) const;
-  static inline isl::map_list alloc(isl::ctx ctx, int n);
+  inline isl::map at(int index) const;
+  inline isl::map get_at(int index) const;
   inline isl::map_list clear() const;
   inline isl::map_list concat(isl::map_list list2) const;
   inline isl::map_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(map)> &fn) const;
-  static inline isl::map_list from_map(isl::map el);
-  inline isl::map get_at(int index) const;
-  inline isl::map get_map(int index) const;
+  inline stat foreach(const std::function<stat(isl::map)> &fn) const;
   inline isl::map_list insert(unsigned int pos, isl::map el) const;
-  inline isl_size n_map() const;
-  inline isl::map_list reverse() const;
-  inline isl::map_list set_map(int index, isl::map el) const;
-  inline isl_size size() const;
-  inline isl::map_list swap(unsigned int pos1, unsigned int pos2) const;
-};
-
-// declarations for isl::mat
-inline mat manage(__isl_take isl_mat *ptr);
-inline mat manage_copy(__isl_keep isl_mat *ptr);
-
-class mat {
-  friend inline mat manage(__isl_take isl_mat *ptr);
-  friend inline mat manage_copy(__isl_keep isl_mat *ptr);
-
-  isl_mat *ptr = nullptr;
-
-  inline explicit mat(__isl_take isl_mat *ptr);
-
-public:
-  inline /* implicit */ mat();
-  inline /* implicit */ mat(const mat &obj);
-  inline mat &operator=(mat obj);
-  inline ~mat();
-  inline __isl_give isl_mat *copy() const &;
-  inline __isl_give isl_mat *copy() && = delete;
-  inline __isl_keep isl_mat *get() const;
-  inline __isl_give isl_mat *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::mat add_rows(unsigned int n) const;
-  inline isl::mat add_zero_cols(unsigned int n) const;
-  inline isl::mat add_zero_rows(unsigned int n) const;
-  inline isl::mat aff_direct_sum(isl::mat right) const;
-  static inline isl::mat alloc(isl::ctx ctx, unsigned int n_row, unsigned int n_col);
-  inline isl_size 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 boolean has_linearly_independent_rows(const isl::mat &mat2) 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 boolean is_equal(const isl::mat &mat2) 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 isl_size rank() const;
-  inline isl::mat right_inverse() const;
-  inline isl::mat right_kernel() const;
-  inline isl::mat row_basis() const;
-  inline isl::mat row_basis_extension(isl::mat mat2) const;
-  inline isl_size rows() const;
-  inline isl::mat set_element_si(int row, int col, int v) const;
-  inline isl::mat set_element_val(int row, int col, isl::val v) const;
-  inline isl::mat swap_cols(unsigned int i, unsigned int j) const;
-  inline isl::mat swap_rows(unsigned int i, unsigned int j) const;
-  inline isl::mat transpose() const;
-  inline isl::mat unimodular_complete(int row) const;
-  inline isl::mat vec_concat(isl::vec bot) const;
-  inline isl::vec vec_inverse_product(isl::vec vec) const;
-  inline isl::vec vec_product(isl::vec vec) const;
+  inline class size size() const;
 };
 
 // declarations for isl::multi_aff
 inline multi_aff manage(__isl_take isl_multi_aff *ptr);
 inline multi_aff manage_copy(__isl_keep isl_multi_aff *ptr);
 
 class multi_aff {
   friend inline multi_aff manage(__isl_take isl_multi_aff *ptr);
   friend inline multi_aff manage_copy(__isl_keep isl_multi_aff *ptr);
 
+protected:
   isl_multi_aff *ptr = nullptr;
 
   inline explicit multi_aff(__isl_take isl_multi_aff *ptr);
 
 public:
   inline /* implicit */ multi_aff();
   inline /* implicit */ multi_aff(const multi_aff &obj);
   inline /* implicit */ multi_aff(isl::aff aff);
   inline explicit multi_aff(isl::space space, isl::aff_list list);
   inline explicit multi_aff(isl::ctx ctx, const std::string &str);
   inline multi_aff &operator=(multi_aff obj);
   inline ~multi_aff();
   inline __isl_give isl_multi_aff *copy() const &;
   inline __isl_give isl_multi_aff *copy() && = delete;
   inline __isl_keep isl_multi_aff *get() const;
   inline __isl_give isl_multi_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::multi_aff add(isl::multi_aff multi2) const;
+  inline isl::multi_pw_aff add(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff add(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff add(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_aff add(const isl::aff &multi2) const;
   inline isl::multi_aff add_constant(isl::multi_val mv) const;
   inline isl::multi_aff add_constant(isl::val v) const;
-  inline isl::multi_aff add_dims(isl::dim type, unsigned int n) const;
-  inline isl::multi_aff align_params(isl::space model) const;
+  inline isl::multi_aff add_constant(long v) const;
+  inline isl::union_pw_multi_aff add_pw_multi_aff(const isl::pw_multi_aff &pma) const;
+  inline isl::union_pw_multi_aff apply(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::map as_map() const;
+  inline isl::multi_aff as_multi_aff() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::union_map as_union_map() const;
+  inline isl::aff at(int pos) const;
+  inline isl::aff get_at(int pos) const;
   inline isl::basic_set bind(isl::multi_id tuple) const;
   inline isl::multi_aff bind_domain(isl::multi_id tuple) const;
   inline isl::multi_aff bind_domain_wrapped_domain(isl::multi_id tuple) const;
-  inline isl_size dim(isl::dim type) const;
+  inline isl::pw_multi_aff coalesce() const;
+  inline isl::multi_val constant_multi_val() const;
+  inline isl::multi_val get_constant_multi_val() const;
+  inline class size dim(isl::dim type) const;
+  inline isl::set domain() const;
   static inline isl::multi_aff domain_map(isl::space space);
-  inline isl::multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::multi_aff 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::pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::pw_multi_aff extract_pw_multi_aff(const isl::space &space) const;
   inline isl::multi_aff flat_range_product(isl::multi_aff multi2) const;
-  inline isl::multi_aff flatten_domain() const;
-  inline isl::multi_aff flatten_range() const;
+  inline isl::multi_pw_aff flat_range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff flat_range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff flat_range_product(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff flat_range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_aff flat_range_product(const isl::aff &multi2) const;
   inline isl::multi_aff floor() const;
-  inline isl::multi_aff from_range() const;
-  inline isl::aff get_aff(int pos) const;
-  inline isl::aff get_at(int pos) const;
-  inline isl::multi_val get_constant_multi_val() const;
-  inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::space get_domain_space() const;
-  inline isl::aff_list get_list() 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 stat foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const;
   inline isl::multi_aff gist(isl::set context) const;
-  inline isl::multi_aff gist_params(isl::set context) const;
-  inline boolean has_tuple_id(isl::dim type) const;
+  inline isl::union_pw_multi_aff gist(const isl::union_set &context) const;
+  inline isl::multi_aff gist(const isl::basic_set &context) const;
+  inline isl::multi_aff gist(const isl::point &context) const;
+  inline boolean has_range_tuple_id() const;
   static inline isl::multi_aff identity(isl::space space);
   inline isl::multi_aff identity() const;
   static inline isl::multi_aff identity_on_domain(isl::space space);
-  inline isl::multi_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::multi_aff insert_domain(isl::space domain) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::pw_multi_aff intersect_domain(const isl::set &set) const;
+  inline isl::union_pw_multi_aff intersect_domain(const isl::space &space) const;
+  inline isl::union_pw_multi_aff intersect_domain(const isl::union_set &uset) const;
+  inline isl::union_pw_multi_aff intersect_domain_wrapped_domain(const isl::union_set &uset) const;
+  inline isl::union_pw_multi_aff intersect_domain_wrapped_range(const isl::union_set &uset) const;
+  inline isl::pw_multi_aff intersect_params(const isl::set &set) const;
   inline boolean involves_locals() const;
   inline boolean involves_nan() 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 boolean involves_param(const isl::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::id_list &list) const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::aff_list list() const;
+  inline isl::aff_list get_list() const;
+  inline isl::multi_pw_aff max(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_val max_multi_val() const;
+  inline isl::multi_pw_aff min(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_val min_multi_val() const;
+  static inline isl::multi_aff multi_val_on_domain(isl::space space, isl::multi_val mv);
+  inline class size n_piece() const;
   inline isl::multi_aff neg() const;
-  inline int plain_cmp(const isl::multi_aff &multi2) const;
+  inline boolean plain_is_empty() const;
   inline boolean plain_is_equal(const isl::multi_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::aff &multi2) const;
+  inline isl::pw_multi_aff preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) 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_pw_aff product(const isl::multi_pw_aff &multi2) const;
+  inline isl::pw_multi_aff product(const isl::pw_multi_aff &pma2) const;
+  inline isl::multi_aff product(const isl::aff &multi2) const;
   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 boolean range_is_wrapping() const;
+  inline isl::multi_pw_aff pullback(const isl::multi_pw_aff &mpa2) const;
+  inline isl::pw_multi_aff pullback(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff pullback(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_aff pullback(const isl::aff &ma2) const;
+  inline isl::pw_multi_aff_list pw_multi_aff_list() const;
+  inline isl::pw_multi_aff range_factor_domain() const;
+  inline isl::pw_multi_aff range_factor_range() 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_pw_aff range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff range_product(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_aff range_product(const isl::aff &multi2) const;
+  inline isl::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
+  inline isl::multi_aff reset_range_tuple_id() const;
   inline isl::multi_aff reset_tuple_id(isl::dim type) const;
-  inline isl::multi_aff reset_user() const;
   inline isl::multi_aff scale(isl::multi_val mv) const;
   inline isl::multi_aff scale(isl::val v) const;
+  inline isl::multi_aff scale(long v) const;
   inline isl::multi_aff scale_down(isl::multi_val mv) const;
   inline isl::multi_aff scale_down(isl::val v) const;
+  inline isl::multi_aff scale_down(long v) const;
   inline isl::multi_aff set_aff(int pos, isl::aff el) const;
   inline isl::multi_aff set_at(int pos, isl::aff el) const;
-  inline isl::multi_aff set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
-  inline isl::multi_aff set_tuple_id(isl::dim type, isl::id id) const;
-  inline isl::multi_aff set_tuple_name(isl::dim type, const std::string &s) const;
-  inline isl_size size() const;
-  inline isl::multi_aff splice(unsigned int in_pos, unsigned int out_pos, isl::multi_aff multi2) const;
+  inline isl::multi_pw_aff set_at(int pos, const isl::pw_aff &el) const;
+  inline isl::multi_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) const;
+  inline isl::multi_pw_aff set_pw_aff(int pos, const isl::pw_aff &el) const;
+  inline isl::pw_multi_aff set_pw_aff(unsigned int pos, const isl::pw_aff &pa) const;
+  inline isl::multi_aff set_range_tuple(isl::id id) const;
+  inline isl::multi_aff set_range_tuple(const std::string &id) const;
+  inline isl::multi_union_pw_aff set_union_pw_aff(int pos, const isl::union_pw_aff &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::multi_aff sub(isl::multi_aff multi2) const;
+  inline isl::multi_pw_aff sub(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff sub(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff sub(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff sub(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_aff sub(const isl::aff &multi2) const;
+  inline isl::pw_multi_aff subtract_domain(const isl::set &set) const;
+  inline isl::union_pw_multi_aff subtract_domain(const isl::space &space) const;
+  inline isl::union_pw_multi_aff subtract_domain(const isl::union_set &uset) const;
+  inline isl::pw_multi_aff_list to_list() const;
+  inline isl::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::multi_union_pw_aff to_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff to_pw_multi_aff() const;
+  inline isl::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::id tuple_id(isl::dim type) const;
   inline isl::multi_aff unbind_params_insert_domain(isl::multi_id domain) const;
+  inline isl::multi_pw_aff union_add(const isl::multi_pw_aff &mpa2) const;
+  inline isl::multi_union_pw_aff union_add(const isl::multi_union_pw_aff &mupa2) const;
+  inline isl::pw_multi_aff union_add(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff union_add(const isl::union_pw_multi_aff &upma2) const;
   static inline isl::multi_aff zero(isl::space space);
 };
 
 // declarations for isl::multi_id
 inline multi_id manage(__isl_take isl_multi_id *ptr);
 inline multi_id manage_copy(__isl_keep isl_multi_id *ptr);
 
 class multi_id {
   friend inline multi_id manage(__isl_take isl_multi_id *ptr);
   friend inline multi_id manage_copy(__isl_keep isl_multi_id *ptr);
 
+protected:
   isl_multi_id *ptr = nullptr;
 
   inline explicit multi_id(__isl_take isl_multi_id *ptr);
 
 public:
   inline /* implicit */ multi_id();
   inline /* implicit */ multi_id(const multi_id &obj);
   inline explicit multi_id(isl::space space, isl::id_list list);
   inline explicit multi_id(isl::ctx ctx, const std::string &str);
   inline multi_id &operator=(multi_id obj);
   inline ~multi_id();
   inline __isl_give isl_multi_id *copy() const &;
   inline __isl_give isl_multi_id *copy() && = delete;
   inline __isl_keep isl_multi_id *get() const;
   inline __isl_give isl_multi_id *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::multi_id align_params(isl::space model) const;
-  inline isl::multi_id factor_range() const;
-  inline isl::multi_id flat_range_product(isl::multi_id multi2) const;
-  inline isl::multi_id flatten_range() const;
-  inline isl::multi_id from_range() const;
+  inline isl::id at(int pos) const;
   inline isl::id get_at(int pos) const;
-  inline isl::space get_domain_space() const;
-  inline isl::id get_id(int pos) const;
+  inline isl::multi_id flat_range_product(isl::multi_id multi2) const;
+  inline isl::id_list list() const;
   inline isl::id_list get_list() const;
-  inline isl::space get_space() const;
   inline boolean plain_is_equal(const isl::multi_id &multi2) const;
-  inline isl::multi_id range_factor_domain() const;
-  inline isl::multi_id range_factor_range() const;
-  inline boolean range_is_wrapping() const;
   inline isl::multi_id range_product(isl::multi_id multi2) const;
-  inline isl::multi_id range_splice(unsigned int pos, isl::multi_id multi2) const;
-  inline isl::multi_id reset_user() const;
   inline isl::multi_id set_at(int pos, isl::id el) const;
+  inline isl::multi_id set_at(int pos, const std::string &el) const;
   inline isl::multi_id set_id(int pos, isl::id el) const;
-  inline isl_size size() const;
+  inline isl::multi_id set_id(int pos, const std::string &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
 };
 
 // declarations for isl::multi_pw_aff
 inline multi_pw_aff manage(__isl_take isl_multi_pw_aff *ptr);
 inline multi_pw_aff manage_copy(__isl_keep isl_multi_pw_aff *ptr);
 
 class multi_pw_aff {
   friend inline multi_pw_aff manage(__isl_take isl_multi_pw_aff *ptr);
   friend inline multi_pw_aff manage_copy(__isl_keep isl_multi_pw_aff *ptr);
 
+protected:
   isl_multi_pw_aff *ptr = nullptr;
 
   inline explicit multi_pw_aff(__isl_take isl_multi_pw_aff *ptr);
 
 public:
   inline /* implicit */ multi_pw_aff();
   inline /* implicit */ multi_pw_aff(const multi_pw_aff &obj);
   inline /* implicit */ multi_pw_aff(isl::aff aff);
   inline /* implicit */ multi_pw_aff(isl::multi_aff ma);
   inline /* implicit */ multi_pw_aff(isl::pw_aff pa);
   inline explicit multi_pw_aff(isl::space space, isl::pw_aff_list list);
   inline /* implicit */ multi_pw_aff(isl::pw_multi_aff pma);
   inline explicit multi_pw_aff(isl::ctx ctx, const std::string &str);
   inline multi_pw_aff &operator=(multi_pw_aff obj);
   inline ~multi_pw_aff();
   inline __isl_give isl_multi_pw_aff *copy() const &;
   inline __isl_give isl_multi_pw_aff *copy() && = delete;
   inline __isl_keep isl_multi_pw_aff *get() const;
   inline __isl_give isl_multi_pw_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::multi_pw_aff add(isl::multi_pw_aff multi2) const;
+  inline isl::multi_union_pw_aff add(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::multi_pw_aff add(const isl::aff &multi2) const;
+  inline isl::multi_pw_aff add(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff add(const isl::pw_aff &multi2) const;
+  inline isl::multi_pw_aff add(const isl::pw_multi_aff &multi2) const;
   inline isl::multi_pw_aff add_constant(isl::multi_val mv) const;
   inline isl::multi_pw_aff add_constant(isl::val v) const;
-  inline isl::multi_pw_aff add_dims(isl::dim type, unsigned int n) const;
-  inline isl::multi_pw_aff align_params(isl::space model) const;
+  inline isl::multi_pw_aff add_constant(long v) const;
+  inline isl::map as_map() const;
+  inline isl::multi_aff as_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::pw_aff at(int pos) const;
+  inline isl::pw_aff get_at(int pos) const;
   inline isl::set bind(isl::multi_id tuple) const;
   inline isl::multi_pw_aff bind_domain(isl::multi_id tuple) const;
   inline isl::multi_pw_aff bind_domain_wrapped_domain(isl::multi_id tuple) const;
   inline isl::multi_pw_aff coalesce() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
   inline isl::set domain() const;
-  inline isl::multi_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::map eq_map(isl::multi_pw_aff mpa2) const;
-  inline isl::multi_pw_aff 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::multi_pw_aff flat_range_product(isl::multi_pw_aff multi2) const;
-  inline isl::multi_pw_aff flatten_range() const;
-  inline isl::multi_pw_aff from_range() const;
-  inline isl::pw_aff get_at(int pos) const;
-  inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
-  inline isl::space get_domain_space() const;
-  inline uint32_t get_hash() const;
-  inline isl::pw_aff_list get_list() 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_union_pw_aff flat_range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::aff &multi2) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::pw_aff &multi2) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::pw_multi_aff &multi2) const;
   inline isl::multi_pw_aff gist(isl::set set) const;
-  inline isl::multi_pw_aff gist_params(isl::set set) const;
-  inline boolean has_tuple_id(isl::dim type) const;
+  inline isl::multi_union_pw_aff gist(const isl::union_set &context) const;
+  inline isl::multi_pw_aff gist(const isl::basic_set &set) const;
+  inline isl::multi_pw_aff gist(const isl::point &set) const;
+  inline boolean has_range_tuple_id() const;
   static inline isl::multi_pw_aff identity(isl::space space);
   inline isl::multi_pw_aff identity() const;
   static inline isl::multi_pw_aff identity_on_domain(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 insert_domain(isl::space domain) const;
   inline isl::multi_pw_aff intersect_domain(isl::set domain) const;
+  inline isl::multi_union_pw_aff intersect_domain(const isl::union_set &uset) const;
+  inline isl::multi_pw_aff intersect_domain(const isl::basic_set &domain) const;
+  inline isl::multi_pw_aff intersect_domain(const isl::point &domain) const;
   inline isl::multi_pw_aff intersect_params(isl::set set) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline boolean involves_nan() const;
   inline boolean involves_param(const isl::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
   inline boolean involves_param(const isl::id_list &list) const;
-  inline boolean is_cst() const;
-  inline boolean is_equal(const isl::multi_pw_aff &mpa2) const;
-  inline isl::map lex_ge_map(isl::multi_pw_aff mpa2) const;
-  inline isl::map lex_gt_map(isl::multi_pw_aff mpa2) const;
-  inline isl::map lex_le_map(isl::multi_pw_aff mpa2) const;
-  inline isl::map lex_lt_map(isl::multi_pw_aff mpa2) const;
+  inline boolean isa_multi_aff() const;
+  inline isl::pw_aff_list list() const;
+  inline isl::pw_aff_list get_list() const;
   inline isl::multi_pw_aff max(isl::multi_pw_aff multi2) const;
   inline isl::multi_val max_multi_val() const;
   inline isl::multi_pw_aff min(isl::multi_pw_aff multi2) const;
   inline isl::multi_val min_multi_val() 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 boolean plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::pw_multi_aff &multi2) 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::multi_pw_aff mpa2) const;
   inline isl::multi_pw_aff pullback(isl::pw_multi_aff pma) const;
-  inline isl::multi_pw_aff range_factor_domain() const;
-  inline isl::multi_pw_aff range_factor_range() const;
-  inline boolean range_is_wrapping() const;
+  inline isl::multi_union_pw_aff pullback(const isl::union_pw_multi_aff &upma) 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_union_pw_aff range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::multi_pw_aff range_product(const isl::aff &multi2) const;
+  inline isl::multi_pw_aff range_product(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff range_product(const isl::pw_aff &multi2) const;
+  inline isl::multi_pw_aff range_product(const isl::pw_multi_aff &multi2) const;
+  inline isl::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
+  inline isl::multi_pw_aff reset_range_tuple_id() 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(isl::multi_val mv) const;
   inline isl::multi_pw_aff scale(isl::val v) const;
+  inline isl::multi_pw_aff scale(long v) const;
   inline isl::multi_pw_aff scale_down(isl::multi_val mv) const;
   inline isl::multi_pw_aff scale_down(isl::val v) const;
+  inline isl::multi_pw_aff scale_down(long v) const;
   inline isl::multi_pw_aff set_at(int pos, isl::pw_aff el) const;
-  inline isl::multi_pw_aff set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
+  inline isl::multi_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) const;
   inline isl::multi_pw_aff set_pw_aff(int pos, isl::pw_aff el) const;
-  inline isl::multi_pw_aff set_tuple_id(isl::dim type, isl::id id) const;
-  inline isl::multi_pw_aff set_tuple_name(isl::dim type, const std::string &s) const;
-  inline isl_size size() const;
-  inline isl::multi_pw_aff splice(unsigned int in_pos, unsigned int out_pos, isl::multi_pw_aff multi2) const;
+  inline isl::multi_pw_aff set_range_tuple(isl::id id) const;
+  inline isl::multi_pw_aff set_range_tuple(const std::string &id) const;
+  inline isl::multi_union_pw_aff set_union_pw_aff(int pos, const isl::union_pw_aff &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::multi_pw_aff sub(isl::multi_pw_aff multi2) const;
+  inline isl::multi_union_pw_aff sub(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::multi_pw_aff sub(const isl::aff &multi2) const;
+  inline isl::multi_pw_aff sub(const isl::multi_aff &multi2) const;
+  inline isl::multi_pw_aff sub(const isl::pw_aff &multi2) const;
+  inline isl::multi_pw_aff sub(const isl::pw_multi_aff &multi2) const;
   inline isl::multi_pw_aff unbind_params_insert_domain(isl::multi_id domain) const;
   inline isl::multi_pw_aff union_add(isl::multi_pw_aff mpa2) const;
+  inline isl::multi_union_pw_aff union_add(const isl::multi_union_pw_aff &mupa2) const;
+  inline isl::multi_pw_aff union_add(const isl::aff &mpa2) const;
+  inline isl::multi_pw_aff union_add(const isl::multi_aff &mpa2) const;
+  inline isl::multi_pw_aff union_add(const isl::pw_aff &mpa2) const;
+  inline isl::multi_pw_aff union_add(const isl::pw_multi_aff &mpa2) const;
   static inline isl::multi_pw_aff zero(isl::space space);
 };
 
 // declarations for isl::multi_union_pw_aff
 inline multi_union_pw_aff manage(__isl_take isl_multi_union_pw_aff *ptr);
 inline multi_union_pw_aff manage_copy(__isl_keep isl_multi_union_pw_aff *ptr);
 
 class multi_union_pw_aff {
   friend inline multi_union_pw_aff manage(__isl_take isl_multi_union_pw_aff *ptr);
   friend inline multi_union_pw_aff manage_copy(__isl_keep isl_multi_union_pw_aff *ptr);
 
+protected:
   isl_multi_union_pw_aff *ptr = nullptr;
 
   inline explicit multi_union_pw_aff(__isl_take isl_multi_union_pw_aff *ptr);
 
 public:
   inline /* implicit */ multi_union_pw_aff();
   inline /* implicit */ multi_union_pw_aff(const multi_union_pw_aff &obj);
   inline /* implicit */ multi_union_pw_aff(isl::multi_pw_aff mpa);
   inline /* implicit */ multi_union_pw_aff(isl::union_pw_aff upa);
   inline explicit multi_union_pw_aff(isl::space space, isl::union_pw_aff_list list);
   inline explicit multi_union_pw_aff(isl::union_pw_multi_aff upma);
   inline explicit multi_union_pw_aff(isl::ctx ctx, const std::string &str);
   inline multi_union_pw_aff &operator=(multi_union_pw_aff obj);
   inline ~multi_union_pw_aff();
   inline __isl_give isl_multi_union_pw_aff *copy() const &;
   inline __isl_give isl_multi_union_pw_aff *copy() && = delete;
   inline __isl_keep isl_multi_union_pw_aff *get() const;
   inline __isl_give isl_multi_union_pw_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::multi_union_pw_aff add(isl::multi_union_pw_aff multi2) const;
-  inline isl::multi_union_pw_aff align_params(isl::space model) const;
-  inline isl::union_pw_aff apply_aff(isl::aff aff) const;
-  inline isl::union_pw_aff apply_pw_aff(isl::pw_aff pa) const;
-  inline isl::multi_union_pw_aff apply_pw_multi_aff(isl::pw_multi_aff pma) const;
+  inline isl::union_pw_aff at(int pos) const;
+  inline isl::union_pw_aff get_at(int pos) const;
   inline isl::union_set bind(isl::multi_id tuple) const;
   inline isl::multi_union_pw_aff coalesce() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
   inline isl::union_set domain() const;
-  inline isl::multi_union_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::multi_pw_aff extract_multi_pw_aff(isl::space space) const;
-  inline isl::multi_union_pw_aff 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::multi_union_pw_aff flat_range_product(isl::multi_union_pw_aff multi2) const;
-  inline isl::multi_union_pw_aff flatten_range() const;
-  inline isl::multi_union_pw_aff floor() const;
-  static inline isl::multi_union_pw_aff from_multi_aff(isl::multi_aff ma);
-  inline isl::multi_union_pw_aff from_range() const;
   static inline isl::multi_union_pw_aff from_union_map(isl::union_map umap);
-  inline isl::union_pw_aff get_at(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::union_pw_aff_list get_list() 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 boolean has_tuple_id(isl::dim type) const;
+  inline boolean has_range_tuple_id() 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 boolean involves_nan() const;
-  inline isl::multi_val max_multi_val() const;
-  inline isl::multi_val min_multi_val() 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::union_pw_aff_list list() const;
+  inline isl::union_pw_aff_list get_list() const;
   inline isl::multi_union_pw_aff neg() const;
   inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) 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 boolean range_is_wrapping() 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::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
+  inline isl::multi_union_pw_aff reset_range_tuple_id() 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(isl::multi_val mv) const;
   inline isl::multi_union_pw_aff scale(isl::val v) const;
+  inline isl::multi_union_pw_aff scale(long v) const;
   inline isl::multi_union_pw_aff scale_down(isl::multi_val mv) const;
   inline isl::multi_union_pw_aff scale_down(isl::val v) const;
+  inline isl::multi_union_pw_aff scale_down(long v) const;
   inline isl::multi_union_pw_aff set_at(int pos, isl::union_pw_aff el) const;
-  inline isl::multi_union_pw_aff set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
-  inline isl::multi_union_pw_aff set_tuple_id(isl::dim type, isl::id id) const;
-  inline isl::multi_union_pw_aff set_tuple_name(isl::dim type, const std::string &s) const;
+  inline isl::multi_union_pw_aff set_range_tuple(isl::id id) const;
+  inline isl::multi_union_pw_aff set_range_tuple(const std::string &id) const;
   inline isl::multi_union_pw_aff set_union_pw_aff(int pos, isl::union_pw_aff el) const;
-  inline isl_size size() const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::multi_union_pw_aff sub(isl::multi_union_pw_aff multi2) const;
   inline isl::multi_union_pw_aff union_add(isl::multi_union_pw_aff mupa2) const;
   static inline isl::multi_union_pw_aff zero(isl::space space);
-  inline isl::union_set zero_union_set() const;
 };
 
 // declarations for isl::multi_val
 inline multi_val manage(__isl_take isl_multi_val *ptr);
 inline multi_val manage_copy(__isl_keep isl_multi_val *ptr);
 
 class multi_val {
   friend inline multi_val manage(__isl_take isl_multi_val *ptr);
   friend inline multi_val manage_copy(__isl_keep isl_multi_val *ptr);
 
+protected:
   isl_multi_val *ptr = nullptr;
 
   inline explicit multi_val(__isl_take isl_multi_val *ptr);
 
 public:
   inline /* implicit */ multi_val();
   inline /* implicit */ multi_val(const multi_val &obj);
   inline explicit multi_val(isl::space space, isl::val_list list);
   inline explicit multi_val(isl::ctx ctx, const std::string &str);
   inline multi_val &operator=(multi_val obj);
   inline ~multi_val();
   inline __isl_give isl_multi_val *copy() const &;
   inline __isl_give isl_multi_val *copy() && = delete;
   inline __isl_keep isl_multi_val *get() const;
   inline __isl_give isl_multi_val *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::multi_val add(isl::multi_val multi2) const;
   inline isl::multi_val add(isl::val v) const;
-  inline isl::multi_val add_dims(isl::dim type, unsigned int n) const;
-  inline isl::multi_val align_params(isl::space model) const;
-  inline isl_size dim(isl::dim type) const;
-  inline isl::multi_val drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::multi_val 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::multi_val flat_range_product(isl::multi_val multi2) const;
-  inline isl::multi_val flatten_range() const;
-  inline isl::multi_val from_range() const;
+  inline isl::multi_val add(long v) const;
+  inline isl::val at(int pos) const;
   inline isl::val get_at(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::val_list get_list() 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 boolean has_tuple_id(isl::dim type) const;
-  inline isl::multi_val insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline class size dim(isl::dim type) const;
+  inline isl::multi_val flat_range_product(isl::multi_val multi2) const;
+  inline boolean has_range_tuple_id() const;
   inline boolean involves_nan() const;
-  inline boolean is_zero() const;
+  inline isl::val_list list() const;
+  inline isl::val_list get_list() const;
   inline isl::multi_val max(isl::multi_val multi2) const;
   inline isl::multi_val min(isl::multi_val multi2) 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 boolean plain_is_equal(const isl::multi_val &multi2) 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 boolean range_is_wrapping() 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::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
+  inline isl::multi_val reset_range_tuple_id() const;
   inline isl::multi_val reset_tuple_id(isl::dim type) const;
-  inline isl::multi_val reset_user() const;
   inline isl::multi_val scale(isl::multi_val mv) const;
   inline isl::multi_val scale(isl::val v) const;
+  inline isl::multi_val scale(long v) const;
   inline isl::multi_val scale_down(isl::multi_val mv) const;
   inline isl::multi_val scale_down(isl::val v) const;
+  inline isl::multi_val scale_down(long v) const;
   inline isl::multi_val set_at(int pos, isl::val el) const;
-  inline isl::multi_val set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
-  inline isl::multi_val set_tuple_id(isl::dim type, isl::id id) const;
-  inline isl::multi_val set_tuple_name(isl::dim type, const std::string &s) const;
+  inline isl::multi_val set_at(int pos, long el) const;
+  inline isl::multi_val set_range_tuple(isl::id id) const;
+  inline isl::multi_val set_range_tuple(const std::string &id) const;
   inline isl::multi_val set_val(int pos, isl::val el) const;
-  inline isl_size size() const;
-  inline isl::multi_val splice(unsigned int in_pos, unsigned int out_pos, isl::multi_val multi2) const;
+  inline isl::multi_val set_val(int pos, long el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::multi_val sub(isl::multi_val multi2) const;
   static inline isl::multi_val zero(isl::space space);
 };
 
 // declarations for isl::point
 inline point manage(__isl_take isl_point *ptr);
 inline point manage_copy(__isl_keep isl_point *ptr);
 
 class point {
   friend inline point manage(__isl_take isl_point *ptr);
   friend inline point manage_copy(__isl_keep isl_point *ptr);
 
+protected:
   isl_point *ptr = nullptr;
 
   inline explicit point(__isl_take isl_point *ptr);
 
 public:
   inline /* implicit */ point();
   inline /* implicit */ point(const point &obj);
-  inline explicit point(isl::space dim);
+  inline explicit point(isl::space space);
   inline point &operator=(point obj);
   inline ~point();
   inline __isl_give isl_point *copy() const &;
   inline __isl_give isl_point *copy() && = delete;
   inline __isl_keep isl_point *get() const;
   inline __isl_give isl_point *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::point add_ui(isl::dim type, int pos, unsigned int val) const;
+  inline isl::set add_constraint(const isl::constraint &constraint) const;
+  inline isl::set add_dims(isl::dim type, unsigned int n) const;
+  inline isl::basic_set affine_hull() const;
+  inline isl::set align_params(const isl::space &model) const;
+  inline isl::basic_set apply(const isl::basic_map &bmap) const;
+  inline isl::set apply(const isl::map &map) const;
+  inline isl::union_set apply(const isl::union_map &umap) const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::basic_set_list basic_set_list() const;
+  inline isl::set bind(const isl::multi_id &tuple) const;
+  inline isl::set coalesce() const;
+  inline isl::set complement() const;
+  inline isl::union_set compute_divs() const;
+  inline boolean contains(const isl::space &space) const;
+  inline isl::basic_set convex_hull() const;
+  inline isl::val coordinate_val(isl::dim type, int pos) const;
   inline isl::val get_coordinate_val(isl::dim type, int pos) const;
+  inline isl::basic_set detect_equalities() const;
+  inline class size dim(isl::dim type) const;
+  inline boolean dim_has_any_lower_bound(isl::dim type, unsigned int pos) const;
+  inline isl::id dim_id(isl::dim type, unsigned int pos) const;
+  inline isl::pw_aff dim_max(int pos) const;
+  inline isl::val dim_max_val(int pos) const;
+  inline isl::pw_aff dim_min(int pos) const;
+  inline isl::val dim_min_val(int pos) const;
+  inline std::string dim_name(isl::dim type, unsigned int pos) const;
+  inline isl::aff div(int pos) const;
+  inline isl::set drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::set eliminate(isl::dim type, unsigned int first, unsigned int n) const;
+  inline boolean every_set(const std::function<boolean(isl::set)> &test) const;
+  inline isl::set extract_set(const isl::space &space) const;
+  inline int find_dim_by_id(isl::dim type, const isl::id &id) const;
+  inline int find_dim_by_id(isl::dim type, const std::string &id) const;
+  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, const isl::val &v) const;
+  inline isl::basic_set fix_val(isl::dim type, unsigned int pos, long v) const;
+  inline isl::basic_set flatten() const;
+  inline stat foreach_basic_set(const std::function<stat(isl::basic_set)> &fn) const;
+  inline stat foreach_point(const std::function<stat(isl::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::set)> &fn) const;
+  inline isl::basic_set gist(const isl::basic_set &context) const;
+  inline isl::set gist(const isl::set &context) const;
+  inline isl::union_set gist(const isl::union_set &context) const;
+  inline isl::set gist_params(const isl::set &context) const;
+  inline boolean has_equal_space(const isl::set &set2) const;
+  inline isl::map identity() const;
+  inline isl::union_pw_multi_aff identity_union_pw_multi_aff() 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::map insert_domain(const isl::space &domain) const;
+  inline isl::basic_set intersect(const isl::basic_set &bset2) const;
+  inline isl::set intersect(const isl::set &set2) const;
+  inline isl::union_set intersect(const isl::union_set &uset2) const;
+  inline isl::basic_set intersect_params(const isl::basic_set &bset2) const;
+  inline isl::set intersect_params(const isl::set &params) const;
+  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline boolean involves_locals() const;
+  inline boolean is_bounded() const;
+  inline boolean is_disjoint(const isl::set &set2) const;
+  inline boolean is_disjoint(const isl::union_set &uset2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::basic_set &bset2) const;
+  inline boolean is_equal(const isl::set &set2) const;
+  inline boolean is_equal(const isl::union_set &uset2) const;
+  inline boolean is_params() const;
+  inline boolean is_singleton() const;
+  inline boolean is_strict_subset(const isl::set &set2) const;
+  inline boolean is_strict_subset(const isl::union_set &uset2) const;
+  inline boolean is_subset(const isl::basic_set &bset2) const;
+  inline boolean is_subset(const isl::set &set2) const;
+  inline boolean is_subset(const isl::union_set &uset2) const;
+  inline boolean is_wrapping() const;
+  inline boolean isa_set() 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(const isl::multi_pw_aff &lower) const;
+  inline isl::set lower_bound(const isl::multi_val &lower) 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, const isl::val &value) const;
+  inline isl::set lower_bound_val(isl::dim type, unsigned int pos, long value) const;
+  inline isl::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::val max_val(const isl::aff &obj) const;
+  inline isl::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::val min_val(const isl::aff &obj) const;
+  inline isl::multi_val multi_val() const;
   inline isl::multi_val get_multi_val() const;
-  inline isl::space get_space() const;
-  inline isl::point set_coordinate_val(isl::dim type, int pos, isl::val v) const;
-  inline isl::point sub_ui(isl::dim type, int pos, unsigned int val) const;
+  inline class size n_basic_set() const;
+  inline isl::basic_set params() const;
+  inline isl::val plain_get_val_if_fixed(isl::dim type, unsigned int pos) const;
+  inline isl::multi_val plain_multi_val_if_fixed() const;
+  inline isl::basic_set polyhedral_hull() const;
+  inline isl::set preimage(const isl::multi_aff &ma) const;
+  inline isl::set preimage(const isl::multi_pw_aff &mpa) const;
+  inline isl::set preimage(const isl::pw_multi_aff &pma) const;
+  inline isl::union_set preimage(const isl::union_pw_multi_aff &upma) const;
+  inline isl::set product(const isl::set &set2) const;
+  inline isl::basic_set project_out(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::set project_out_all_params() const;
+  inline isl::set project_out_param(const isl::id &id) const;
+  inline isl::set project_out_param(const std::string &id) const;
+  inline isl::set project_out_param(const isl::id_list &list) const;
+  inline isl::pw_multi_aff pw_multi_aff_on_domain(const isl::multi_val &mv) const;
+  inline isl::set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::set remove_divs() const;
+  inline isl::set remove_redundancies() const;
+  inline isl::set reset_tuple_id() const;
+  inline isl::basic_set sample() const;
+  inline isl::point sample_point() const;
+  inline isl::set set_dim_id(isl::dim type, unsigned int pos, const isl::id &id) const;
+  inline isl::set set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const;
+  inline isl::set_list set_list() const;
+  inline isl::set set_tuple_id(const isl::id &id) const;
+  inline isl::set set_tuple_id(const std::string &id) const;
+  inline isl::fixed_box simple_fixed_box_hull() const;
+  inline isl::basic_set simple_hull() const;
+  inline isl::space space() const;
+  inline isl::val stride(int pos) const;
+  inline isl::set subtract(const isl::set &set2) const;
+  inline isl::union_set subtract(const isl::union_set &uset2) const;
+  inline isl::basic_set_list to_list() const;
+  inline isl::set to_set() const;
+  inline isl::union_set to_union_set() const;
+  inline isl::map translation() const;
+  inline class size tuple_dim() const;
+  inline isl::id tuple_id() const;
+  inline std::string tuple_name() const;
+  inline isl::set unbind_params(const isl::multi_id &tuple) const;
+  inline isl::map unbind_params_insert_domain(const isl::multi_id &domain) const;
+  inline isl::set unite(const isl::basic_set &bset2) const;
+  inline isl::set unite(const isl::set &set2) const;
+  inline isl::union_set unite(const isl::union_set &uset2) const;
+  inline isl::basic_set unshifted_simple_hull() const;
+  inline isl::map unwrap() const;
+  inline isl::set upper_bound(const isl::multi_pw_aff &upper) const;
+  inline isl::set upper_bound(const isl::multi_val &upper) const;
+  inline isl::set upper_bound_val(isl::dim type, unsigned int pos, const isl::val &value) const;
+  inline isl::set upper_bound_val(isl::dim type, unsigned int pos, long value) const;
 };
 
 // declarations for isl::pw_aff
 inline pw_aff manage(__isl_take isl_pw_aff *ptr);
 inline pw_aff manage_copy(__isl_keep isl_pw_aff *ptr);
 
 class pw_aff {
   friend inline pw_aff manage(__isl_take isl_pw_aff *ptr);
   friend inline pw_aff manage_copy(__isl_keep isl_pw_aff *ptr);
 
+protected:
   isl_pw_aff *ptr = nullptr;
 
   inline explicit pw_aff(__isl_take isl_pw_aff *ptr);
 
 public:
   inline /* implicit */ pw_aff();
   inline /* implicit */ pw_aff(const pw_aff &obj);
   inline /* implicit */ pw_aff(isl::aff aff);
   inline explicit pw_aff(isl::ctx ctx, const std::string &str);
   inline explicit pw_aff(isl::set domain, isl::val v);
   inline explicit pw_aff(isl::local_space ls);
   inline pw_aff &operator=(pw_aff obj);
   inline ~pw_aff();
   inline __isl_give isl_pw_aff *copy() const &;
   inline __isl_give isl_pw_aff *copy() && = delete;
   inline __isl_keep isl_pw_aff *get() const;
   inline __isl_give isl_pw_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
+  inline isl::multi_pw_aff add(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff add(const isl::multi_union_pw_aff &multi2) const;
   inline isl::pw_aff add(isl::pw_aff pwaff2) const;
+  inline isl::pw_multi_aff add(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_aff add(const isl::union_pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_aff add(const isl::aff &pwaff2) const;
   inline isl::pw_aff add_constant(isl::val v) const;
+  inline isl::pw_aff add_constant(long v) const;
+  inline isl::pw_multi_aff add_constant(const isl::multi_val &mv) const;
   inline isl::pw_aff add_dims(isl::dim type, unsigned int n) const;
-  inline isl::pw_aff align_params(isl::space model) const;
-  static inline isl::pw_aff alloc(isl::set set, isl::aff aff);
+  inline isl::union_pw_multi_aff add_pw_multi_aff(const isl::pw_multi_aff &pma) const;
+  inline isl::union_pw_multi_aff apply(const isl::union_pw_multi_aff &upma2) const;
   inline isl::aff as_aff() const;
+  inline isl::map as_map() const;
+  inline isl::multi_aff as_multi_aff() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::union_map as_union_map() const;
+  inline isl::pw_aff at(int pos) const;
+  inline isl::set bind(const isl::multi_id &tuple) const;
   inline isl::set bind(isl::id id) const;
+  inline isl::set bind(const std::string &id) const;
   inline isl::pw_aff bind_domain(isl::multi_id tuple) const;
   inline isl::pw_aff bind_domain_wrapped_domain(isl::multi_id tuple) const;
   inline isl::pw_aff ceil() const;
   inline isl::pw_aff coalesce() const;
   inline isl::pw_aff cond(isl::pw_aff pwaff_true, isl::pw_aff pwaff_false) const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
+  inline isl::id dim_id(isl::dim type, unsigned int pos) const;
+  inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::pw_aff div(isl::pw_aff pa2) const;
   inline isl::set domain() const;
-  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 space);
-  inline isl::map eq_map(isl::pw_aff pa2) const;
+  inline isl::space domain_space() const;
+  inline isl::space get_domain_space() const;
+  inline isl::pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) 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_multi_aff extract_pw_multi_aff(const isl::space &space) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff flat_range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff flat_range_product(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff flat_range_product(const isl::union_pw_multi_aff &upma2) const;
   inline isl::pw_aff floor() const;
-  inline stat foreach_piece(const std::function<stat(set, aff)> &fn) const;
-  inline isl::pw_aff from_range() const;
-  inline isl::map ge_map(isl::pw_aff pa2) const;
+  inline stat foreach_piece(const std::function<stat(isl::set, isl::aff)> &fn) const;
+  inline stat foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const;
+  inline stat foreach_pw_aff(const std::function<stat(isl::pw_aff)> &fn) 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::union_pw_aff gist(const isl::union_set &context) const;
+  inline isl::pw_aff gist(const isl::basic_set &context) const;
+  inline isl::pw_aff gist(const isl::point &context) const;
   inline isl::set gt_set(isl::pw_aff pwaff2) const;
-  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline boolean has_tuple_id(isl::dim type) const;
-  inline isl::pw_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::multi_pw_aff identity() const;
   inline isl::pw_aff insert_domain(isl::space domain) const;
   inline isl::pw_aff intersect_domain(isl::set set) const;
-  inline isl::pw_aff intersect_domain_wrapped_domain(isl::set set) const;
-  inline isl::pw_aff intersect_domain_wrapped_range(isl::set set) const;
+  inline isl::union_pw_aff intersect_domain(const isl::space &space) const;
+  inline isl::union_pw_aff intersect_domain(const isl::union_set &uset) const;
+  inline isl::pw_aff intersect_domain(const isl::basic_set &set) const;
+  inline isl::pw_aff intersect_domain(const isl::point &set) const;
+  inline isl::union_pw_aff intersect_domain_wrapped_domain(const isl::union_set &uset) const;
+  inline isl::union_pw_aff intersect_domain_wrapped_range(const isl::union_set &uset) const;
   inline isl::pw_aff intersect_params(isl::set set) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline boolean involves_locals() const;
   inline boolean involves_nan() const;
-  inline boolean involves_param_id(const isl::id &id) const;
+  inline boolean involves_param(const isl::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::id_list &list) const;
   inline boolean is_cst() const;
-  inline boolean is_empty() const;
   inline boolean is_equal(const isl::pw_aff &pa2) const;
   inline boolean isa_aff() const;
-  inline isl::map le_map(isl::pw_aff pa2) const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
   inline isl::set le_set(isl::pw_aff pwaff2) const;
-  inline isl::map lt_map(isl::pw_aff pa2) const;
+  inline isl::pw_aff_list list() const;
   inline isl::set lt_set(isl::pw_aff pwaff2) const;
+  inline isl::multi_pw_aff max(const isl::multi_pw_aff &multi2) const;
   inline isl::pw_aff max(isl::pw_aff pwaff2) const;
+  inline isl::pw_aff max(const isl::aff &pwaff2) const;
+  inline isl::multi_val max_multi_val() const;
+  inline isl::multi_pw_aff min(const isl::multi_pw_aff &multi2) const;
   inline isl::pw_aff min(isl::pw_aff pwaff2) const;
+  inline isl::pw_aff min(const isl::aff &pwaff2) const;
+  inline isl::multi_val min_multi_val() 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 mod(long mod) const;
   inline isl::pw_aff mul(isl::pw_aff pwaff2) const;
-  inline isl_size n_piece() const;
-  static inline isl::pw_aff nan_on_domain(isl::local_space ls);
-  static inline isl::pw_aff nan_on_domain_space(isl::space space);
+  inline class size n_piece() const;
   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;
   static inline isl::pw_aff param_on_domain(isl::set domain, isl::id id);
-  inline isl::set params() const;
-  inline int plain_cmp(const isl::pw_aff &pa2) const;
-  inline boolean plain_is_equal(const isl::pw_aff &pwaff2) const;
-  inline isl::set pos_set() const;
-  inline isl::pw_aff project_domain_on_params() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_pw_aff product(const isl::multi_pw_aff &multi2) const;
+  inline isl::pw_multi_aff product(const isl::pw_multi_aff &pma2) const;
   inline isl::pw_aff pullback(isl::multi_aff ma) const;
   inline isl::pw_aff pullback(isl::multi_pw_aff mpa) const;
   inline isl::pw_aff pullback(isl::pw_multi_aff pma) const;
-  inline isl::pw_aff reset_tuple_id(isl::dim type) const;
-  inline isl::pw_aff reset_user() const;
+  inline isl::union_pw_aff pullback(const isl::union_pw_multi_aff &upma) const;
+  inline isl::pw_multi_aff_list pw_multi_aff_list() const;
+  inline isl::pw_multi_aff range_factor_domain() const;
+  inline isl::pw_multi_aff range_factor_range() const;
+  inline isl::multi_pw_aff range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::pw_multi_aff range_product(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_multi_aff range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::id range_tuple_id() const;
+  inline isl::multi_pw_aff reset_range_tuple_id() const;
+  inline isl::multi_pw_aff reset_tuple_id(isl::dim type) const;
+  inline isl::multi_pw_aff scale(const isl::multi_val &mv) const;
   inline isl::pw_aff scale(isl::val v) const;
+  inline isl::pw_aff scale(long v) const;
+  inline isl::multi_pw_aff scale_down(const isl::multi_val &mv) const;
   inline isl::pw_aff scale_down(isl::val f) const;
-  inline isl::pw_aff set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
+  inline isl::pw_aff scale_down(long f) const;
+  inline isl::multi_pw_aff set_at(int pos, const isl::pw_aff &el) const;
+  inline isl::multi_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) const;
+  inline isl::multi_pw_aff set_pw_aff(int pos, const isl::pw_aff &el) const;
+  inline isl::pw_multi_aff set_pw_aff(unsigned int pos, const isl::pw_aff &pa) const;
+  inline isl::pw_multi_aff set_range_tuple(const isl::id &id) const;
+  inline isl::pw_multi_aff set_range_tuple(const std::string &id) const;
   inline isl::pw_aff set_tuple_id(isl::dim type, isl::id id) const;
+  inline isl::pw_aff set_tuple_id(isl::dim type, const std::string &id) const;
+  inline isl::multi_union_pw_aff set_union_pw_aff(int pos, const isl::union_pw_aff &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
+  inline isl::multi_pw_aff sub(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff sub(const isl::multi_union_pw_aff &multi2) const;
   inline isl::pw_aff sub(isl::pw_aff pwaff2) const;
+  inline isl::pw_multi_aff sub(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_aff sub(const isl::union_pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff sub(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_aff sub(const isl::aff &pwaff2) const;
   inline isl::pw_aff subtract_domain(isl::set set) const;
+  inline isl::union_pw_aff subtract_domain(const isl::space &space) const;
+  inline isl::union_pw_aff subtract_domain(const isl::union_set &uset) const;
+  inline isl::pw_aff subtract_domain(const isl::basic_set &set) const;
+  inline isl::pw_aff subtract_domain(const isl::point &set) const;
   inline isl::pw_aff tdiv_q(isl::pw_aff pa2) const;
   inline isl::pw_aff tdiv_r(isl::pw_aff pa2) const;
+  inline isl::pw_aff_list to_list() const;
+  inline isl::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::union_pw_aff to_union_pw_aff() const;
+  inline isl::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::id tuple_id(isl::dim type) const;
+  inline isl::id get_tuple_id(isl::dim type) const;
+  inline isl::multi_pw_aff unbind_params_insert_domain(const isl::multi_id &domain) const;
+  inline isl::multi_pw_aff union_add(const isl::multi_pw_aff &mpa2) const;
+  inline isl::multi_union_pw_aff union_add(const isl::multi_union_pw_aff &mupa2) const;
   inline isl::pw_aff union_add(isl::pw_aff pwaff2) const;
-  inline isl::pw_aff union_max(isl::pw_aff pwaff2) const;
-  inline isl::pw_aff union_min(isl::pw_aff pwaff2) const;
+  inline isl::pw_multi_aff union_add(const isl::pw_multi_aff &pma2) const;
+  inline isl::union_pw_aff union_add(const isl::union_pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff union_add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_aff union_add(const isl::aff &pwaff2) const;
   static inline isl::pw_aff var_on_domain(isl::local_space ls, isl::dim type, unsigned int pos);
-  inline isl::set zero_set() const;
 };
 
 // declarations for isl::pw_aff_list
 inline pw_aff_list manage(__isl_take isl_pw_aff_list *ptr);
 inline pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr);
 
 class pw_aff_list {
   friend inline pw_aff_list manage(__isl_take isl_pw_aff_list *ptr);
   friend inline pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr);
 
+protected:
   isl_pw_aff_list *ptr = nullptr;
 
   inline explicit pw_aff_list(__isl_take isl_pw_aff_list *ptr);
 
 public:
   inline /* implicit */ pw_aff_list();
   inline /* implicit */ pw_aff_list(const pw_aff_list &obj);
+  inline explicit pw_aff_list(isl::ctx ctx, int n);
+  inline explicit pw_aff_list(isl::pw_aff el);
+  inline explicit pw_aff_list(isl::ctx ctx, const std::string &str);
   inline pw_aff_list &operator=(pw_aff_list obj);
   inline ~pw_aff_list();
   inline __isl_give isl_pw_aff_list *copy() const &;
   inline __isl_give isl_pw_aff_list *copy() && = delete;
   inline __isl_keep isl_pw_aff_list *get() const;
   inline __isl_give isl_pw_aff_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::pw_aff_list add(isl::pw_aff el) const;
-  static inline isl::pw_aff_list alloc(isl::ctx ctx, int n);
+  inline isl::pw_aff at(int index) const;
+  inline isl::pw_aff get_at(int index) const;
   inline isl::pw_aff_list clear() const;
   inline isl::pw_aff_list concat(isl::pw_aff_list list2) const;
   inline isl::pw_aff_list drop(unsigned int first, unsigned int n) const;
-  inline isl::set eq_set(isl::pw_aff_list list2) const;
-  inline stat foreach(const std::function<stat(pw_aff)> &fn) const;
-  static inline isl::pw_aff_list from_pw_aff(isl::pw_aff el);
-  inline isl::set ge_set(isl::pw_aff_list list2) const;
-  inline isl::pw_aff get_at(int index) const;
-  inline isl::pw_aff get_pw_aff(int index) const;
-  inline isl::set gt_set(isl::pw_aff_list list2) const;
+  inline stat foreach(const std::function<stat(isl::pw_aff)> &fn) const;
   inline isl::pw_aff_list insert(unsigned int pos, isl::pw_aff el) const;
-  inline isl::set le_set(isl::pw_aff_list list2) const;
-  inline isl::set lt_set(isl::pw_aff_list list2) const;
-  inline isl::pw_aff max() const;
-  inline isl::pw_aff min() const;
-  inline isl_size n_pw_aff() const;
-  inline isl::set ne_set(isl::pw_aff_list list2) const;
-  inline isl::pw_aff_list reverse() const;
-  inline isl::pw_aff_list set_pw_aff(int index, isl::pw_aff el) const;
-  inline isl_size size() const;
-  inline isl::pw_aff_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
 };
 
 // declarations for isl::pw_multi_aff
 inline pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr);
 inline pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr);
 
 class pw_multi_aff {
   friend inline pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr);
   friend inline pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr);
 
+protected:
   isl_pw_multi_aff *ptr = nullptr;
 
   inline explicit pw_multi_aff(__isl_take isl_pw_multi_aff *ptr);
 
 public:
   inline /* implicit */ pw_multi_aff();
   inline /* implicit */ pw_multi_aff(const pw_multi_aff &obj);
   inline /* implicit */ pw_multi_aff(isl::multi_aff ma);
   inline /* implicit */ pw_multi_aff(isl::pw_aff pa);
   inline explicit pw_multi_aff(isl::ctx ctx, const std::string &str);
   inline pw_multi_aff &operator=(pw_multi_aff obj);
   inline ~pw_multi_aff();
   inline __isl_give isl_pw_multi_aff *copy() const &;
   inline __isl_give isl_pw_multi_aff *copy() && = delete;
   inline __isl_keep isl_pw_multi_aff *get() const;
   inline __isl_give isl_pw_multi_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
+  inline isl::multi_pw_aff add(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff add(const isl::multi_union_pw_aff &multi2) const;
   inline isl::pw_multi_aff add(isl::pw_multi_aff pma2) const;
+  inline isl::union_pw_multi_aff add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff add(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff add(const isl::pw_aff &pma2) const;
   inline isl::pw_multi_aff add_constant(isl::multi_val mv) const;
   inline isl::pw_multi_aff add_constant(isl::val v) const;
-  inline isl::pw_multi_aff align_params(isl::space model) const;
-  static inline isl::pw_multi_aff alloc(isl::set set, isl::multi_aff maff);
+  inline isl::pw_multi_aff add_constant(long v) const;
+  inline isl::union_pw_multi_aff add_pw_multi_aff(const isl::pw_multi_aff &pma) const;
+  inline isl::union_pw_multi_aff apply(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::map as_map() const;
   inline isl::multi_aff as_multi_aff() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::union_map as_union_map() const;
+  inline isl::pw_aff at(int pos) const;
+  inline isl::pw_aff get_at(int pos) const;
+  inline isl::set bind(const isl::multi_id &tuple) const;
   inline isl::pw_multi_aff bind_domain(isl::multi_id tuple) const;
   inline isl::pw_multi_aff bind_domain_wrapped_domain(isl::multi_id tuple) const;
   inline isl::pw_multi_aff coalesce() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
   inline isl::set domain() const;
   static inline isl::pw_multi_aff domain_map(isl::space space);
   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 extract_pw_multi_aff(const isl::space &space) const;
+  inline isl::multi_pw_aff flat_range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff flat_range_product(const isl::multi_union_pw_aff &multi2) const;
   inline isl::pw_multi_aff flat_range_product(isl::pw_multi_aff pma2) const;
-  inline stat foreach_piece(const std::function<stat(set, multi_aff)> &fn) const;
-  static inline isl::pw_multi_aff from_domain(isl::set set);
+  inline isl::union_pw_multi_aff flat_range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff flat_range_product(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff flat_range_product(const isl::pw_aff &pma2) const;
+  inline stat foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const;
   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 boolean has_tuple_id(isl::dim type) const;
-  inline boolean has_tuple_name(isl::dim type) const;
-  static inline isl::pw_multi_aff identity(isl::space space);
+  inline isl::union_pw_multi_aff gist(const isl::union_set &context) const;
+  inline isl::pw_multi_aff gist(const isl::basic_set &set) const;
+  inline isl::pw_multi_aff gist(const isl::point &set) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::multi_pw_aff identity() const;
   static inline isl::pw_multi_aff identity_on_domain(isl::space space);
   inline isl::pw_multi_aff insert_domain(isl::space domain) const;
   inline isl::pw_multi_aff intersect_domain(isl::set set) const;
-  inline isl::pw_multi_aff intersect_domain_wrapped_domain(isl::set set) const;
-  inline isl::pw_multi_aff intersect_domain_wrapped_range(isl::set set) const;
+  inline isl::union_pw_multi_aff intersect_domain(const isl::space &space) const;
+  inline isl::union_pw_multi_aff intersect_domain(const isl::union_set &uset) const;
+  inline isl::pw_multi_aff intersect_domain(const isl::basic_set &set) const;
+  inline isl::pw_multi_aff intersect_domain(const isl::point &set) const;
+  inline isl::union_pw_multi_aff intersect_domain_wrapped_domain(const isl::union_set &uset) const;
+  inline isl::union_pw_multi_aff intersect_domain_wrapped_range(const isl::union_set &uset) const;
   inline isl::pw_multi_aff intersect_params(isl::set set) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline boolean involves_locals() const;
   inline boolean involves_nan() const;
-  inline boolean involves_param_id(const isl::id &id) const;
-  inline boolean is_equal(const isl::pw_multi_aff &pma2) const;
+  inline boolean involves_param(const isl::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::id_list &list) const;
   inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::pw_aff_list list() const;
+  inline isl::multi_pw_aff max(const isl::multi_pw_aff &multi2) const;
   inline isl::multi_val max_multi_val() const;
+  inline isl::multi_pw_aff min(const isl::multi_pw_aff &multi2) const;
   inline isl::multi_val min_multi_val() const;
   static inline isl::pw_multi_aff multi_val_on_domain(isl::set domain, isl::multi_val mv);
-  inline isl_size n_piece() const;
-  inline isl::pw_multi_aff neg() const;
-  inline boolean plain_is_equal(const isl::pw_multi_aff &pma2) const;
+  inline class size n_piece() const;
+  inline isl::multi_pw_aff neg() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
   inline isl::pw_multi_aff preimage_domain_wrapped_domain(isl::pw_multi_aff pma2) const;
+  inline isl::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff preimage_domain_wrapped_domain(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff preimage_domain_wrapped_domain(const isl::pw_aff &pma2) const;
+  inline isl::multi_pw_aff product(const isl::multi_pw_aff &multi2) const;
   inline isl::pw_multi_aff product(isl::pw_multi_aff pma2) const;
-  inline isl::pw_multi_aff project_domain_on_params() const;
+  inline isl::pw_multi_aff product(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff product(const isl::pw_aff &pma2) const;
   static inline isl::pw_multi_aff project_out_map(isl::space space, isl::dim type, unsigned int first, unsigned int n);
+  inline isl::multi_pw_aff pullback(const isl::multi_pw_aff &mpa2) const;
   inline isl::pw_multi_aff pullback(isl::multi_aff ma) const;
   inline isl::pw_multi_aff pullback(isl::pw_multi_aff pma2) const;
+  inline isl::union_pw_multi_aff pullback(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff_list pw_multi_aff_list() const;
   inline isl::pw_multi_aff range_factor_domain() const;
   inline isl::pw_multi_aff range_factor_range() const;
   static inline isl::pw_multi_aff range_map(isl::space space);
+  inline isl::multi_pw_aff range_product(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff range_product(const isl::multi_union_pw_aff &multi2) const;
   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;
-  inline isl::pw_multi_aff reset_user() const;
+  inline isl::union_pw_multi_aff range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff range_product(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff range_product(const isl::pw_aff &pma2) const;
+  inline isl::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
+  inline isl::multi_pw_aff reset_range_tuple_id() const;
+  inline isl::multi_pw_aff reset_tuple_id(isl::dim type) const;
+  inline isl::multi_pw_aff scale(const isl::multi_val &mv) const;
   inline isl::pw_multi_aff scale(isl::val v) const;
+  inline isl::pw_multi_aff scale(long v) const;
+  inline isl::multi_pw_aff scale_down(const isl::multi_val &mv) const;
   inline isl::pw_multi_aff scale_down(isl::val v) const;
-  inline isl::pw_multi_aff scale_multi_val(isl::multi_val mv) const;
-  inline isl::pw_multi_aff set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
+  inline isl::pw_multi_aff scale_down(long v) const;
+  inline isl::multi_pw_aff set_at(int pos, const isl::pw_aff &el) const;
+  inline isl::multi_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) const;
+  inline isl::multi_pw_aff set_pw_aff(int pos, const isl::pw_aff &el) const;
   inline isl::pw_multi_aff set_pw_aff(unsigned int pos, isl::pw_aff pa) const;
-  inline isl::pw_multi_aff set_tuple_id(isl::dim type, isl::id id) const;
+  inline isl::pw_multi_aff set_range_tuple(isl::id id) const;
+  inline isl::pw_multi_aff set_range_tuple(const std::string &id) const;
+  inline isl::multi_union_pw_aff set_union_pw_aff(int pos, const isl::union_pw_aff &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
+  inline isl::multi_pw_aff sub(const isl::multi_pw_aff &multi2) const;
+  inline isl::multi_union_pw_aff sub(const isl::multi_union_pw_aff &multi2) const;
   inline isl::pw_multi_aff sub(isl::pw_multi_aff pma2) const;
+  inline isl::union_pw_multi_aff sub(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff sub(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff sub(const isl::pw_aff &pma2) const;
   inline isl::pw_multi_aff subtract_domain(isl::set set) const;
+  inline isl::union_pw_multi_aff subtract_domain(const isl::space &space) const;
+  inline isl::union_pw_multi_aff subtract_domain(const isl::union_set &uset) const;
+  inline isl::pw_multi_aff subtract_domain(const isl::basic_set &set) const;
+  inline isl::pw_multi_aff subtract_domain(const isl::point &set) const;
+  inline isl::pw_multi_aff_list to_list() const;
+  inline isl::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::id tuple_id(isl::dim type) const;
+  inline isl::id get_tuple_id(isl::dim type) const;
+  inline isl::multi_pw_aff unbind_params_insert_domain(const isl::multi_id &domain) const;
+  inline isl::multi_pw_aff union_add(const isl::multi_pw_aff &mpa2) const;
+  inline isl::multi_union_pw_aff union_add(const isl::multi_union_pw_aff &mupa2) const;
   inline isl::pw_multi_aff union_add(isl::pw_multi_aff pma2) const;
-  inline isl::pw_multi_aff union_lexmax(isl::pw_multi_aff pma2) const;
-  inline isl::pw_multi_aff union_lexmin(isl::pw_multi_aff pma2) const;
+  inline isl::union_pw_multi_aff union_add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::pw_multi_aff union_add(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff union_add(const isl::pw_aff &pma2) const;
   static inline isl::pw_multi_aff zero(isl::space space);
 };
 
 // declarations for isl::pw_multi_aff_list
 inline pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr);
 inline pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr);
 
 class pw_multi_aff_list {
   friend inline pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr);
   friend inline pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr);
 
+protected:
   isl_pw_multi_aff_list *ptr = nullptr;
 
   inline explicit pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr);
 
 public:
   inline /* implicit */ pw_multi_aff_list();
   inline /* implicit */ pw_multi_aff_list(const pw_multi_aff_list &obj);
+  inline explicit pw_multi_aff_list(isl::ctx ctx, int n);
+  inline explicit pw_multi_aff_list(isl::pw_multi_aff el);
+  inline explicit pw_multi_aff_list(isl::ctx ctx, const std::string &str);
   inline pw_multi_aff_list &operator=(pw_multi_aff_list obj);
   inline ~pw_multi_aff_list();
   inline __isl_give isl_pw_multi_aff_list *copy() const &;
   inline __isl_give isl_pw_multi_aff_list *copy() && = delete;
   inline __isl_keep isl_pw_multi_aff_list *get() const;
   inline __isl_give isl_pw_multi_aff_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::pw_multi_aff_list add(isl::pw_multi_aff el) const;
-  static inline isl::pw_multi_aff_list alloc(isl::ctx ctx, int n);
+  inline isl::pw_multi_aff at(int index) const;
+  inline isl::pw_multi_aff get_at(int index) const;
   inline isl::pw_multi_aff_list clear() const;
   inline isl::pw_multi_aff_list concat(isl::pw_multi_aff_list list2) const;
   inline isl::pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(pw_multi_aff)> &fn) const;
-  static inline isl::pw_multi_aff_list from_pw_multi_aff(isl::pw_multi_aff el);
-  inline isl::pw_multi_aff get_at(int index) const;
-  inline isl::pw_multi_aff get_pw_multi_aff(int index) const;
+  inline stat foreach(const std::function<stat(isl::pw_multi_aff)> &fn) const;
   inline isl::pw_multi_aff_list insert(unsigned int pos, isl::pw_multi_aff el) const;
-  inline isl_size n_pw_multi_aff() const;
-  inline isl::pw_multi_aff_list reverse() const;
-  inline isl::pw_multi_aff_list set_pw_multi_aff(int index, isl::pw_multi_aff el) const;
-  inline isl_size size() const;
-  inline isl::pw_multi_aff_list swap(unsigned int pos1, unsigned int pos2) const;
-};
-
-// declarations for isl::pw_qpolynomial
-inline pw_qpolynomial manage(__isl_take isl_pw_qpolynomial *ptr);
-inline pw_qpolynomial manage_copy(__isl_keep isl_pw_qpolynomial *ptr);
-
-class pw_qpolynomial {
-  friend inline pw_qpolynomial manage(__isl_take isl_pw_qpolynomial *ptr);
-  friend inline pw_qpolynomial manage_copy(__isl_keep isl_pw_qpolynomial *ptr);
-
-  isl_pw_qpolynomial *ptr = nullptr;
-
-  inline explicit pw_qpolynomial(__isl_take isl_pw_qpolynomial *ptr);
-
-public:
-  inline /* implicit */ pw_qpolynomial();
-  inline /* implicit */ pw_qpolynomial(const pw_qpolynomial &obj);
-  inline explicit pw_qpolynomial(isl::ctx ctx, const std::string &str);
-  inline pw_qpolynomial &operator=(pw_qpolynomial obj);
-  inline ~pw_qpolynomial();
-  inline __isl_give isl_pw_qpolynomial *copy() const &;
-  inline __isl_give isl_pw_qpolynomial *copy() && = delete;
-  inline __isl_keep isl_pw_qpolynomial *get() const;
-  inline __isl_give isl_pw_qpolynomial *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::pw_qpolynomial add(isl::pw_qpolynomial pwqp2) const;
-  inline isl::pw_qpolynomial add_dims(isl::dim type, unsigned int n) const;
-  static inline isl::pw_qpolynomial alloc(isl::set set, isl::qpolynomial qp);
-  inline isl::qpolynomial as_qpolynomial() const;
-  inline isl::pw_qpolynomial coalesce() const;
-  inline isl_size 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 stat foreach_piece(const std::function<stat(set, 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 boolean has_equal_space(const isl::pw_qpolynomial &pwqp2) 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_domain_wrapped_domain(isl::set set) const;
-  inline isl::pw_qpolynomial intersect_domain_wrapped_range(isl::set set) const;
-  inline isl::pw_qpolynomial intersect_params(isl::set set) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline boolean involves_nan() const;
-  inline boolean involves_param_id(const isl::id &id) const;
-  inline boolean is_zero() const;
-  inline boolean isa_qpolynomial() 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 isl_size n_piece() const;
-  inline isl::pw_qpolynomial neg() const;
-  inline boolean plain_is_equal(const isl::pw_qpolynomial &pwqp2) 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 space) 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;
-  inline isl::pw_qpolynomial sub(isl::pw_qpolynomial pwqp2) const;
-  inline isl::pw_qpolynomial subtract_domain(isl::set set) const;
-  inline isl::pw_qpolynomial to_polynomial(int sign) const;
-  static inline isl::pw_qpolynomial zero(isl::space space);
-};
-
-// declarations for isl::pw_qpolynomial_fold_list
-inline pw_qpolynomial_fold_list manage(__isl_take isl_pw_qpolynomial_fold_list *ptr);
-inline pw_qpolynomial_fold_list manage_copy(__isl_keep isl_pw_qpolynomial_fold_list *ptr);
-
-class pw_qpolynomial_fold_list {
-  friend inline pw_qpolynomial_fold_list manage(__isl_take isl_pw_qpolynomial_fold_list *ptr);
-  friend inline pw_qpolynomial_fold_list manage_copy(__isl_keep isl_pw_qpolynomial_fold_list *ptr);
-
-  isl_pw_qpolynomial_fold_list *ptr = nullptr;
-
-  inline explicit pw_qpolynomial_fold_list(__isl_take isl_pw_qpolynomial_fold_list *ptr);
-
-public:
-  inline /* implicit */ pw_qpolynomial_fold_list();
-  inline /* implicit */ pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj);
-  inline pw_qpolynomial_fold_list &operator=(pw_qpolynomial_fold_list obj);
-  inline ~pw_qpolynomial_fold_list();
-  inline __isl_give isl_pw_qpolynomial_fold_list *copy() const &;
-  inline __isl_give isl_pw_qpolynomial_fold_list *copy() && = delete;
-  inline __isl_keep isl_pw_qpolynomial_fold_list *get() const;
-  inline __isl_give isl_pw_qpolynomial_fold_list *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-};
-
-// declarations for isl::pw_qpolynomial_list
-inline pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr);
-inline pw_qpolynomial_list manage_copy(__isl_keep isl_pw_qpolynomial_list *ptr);
-
-class pw_qpolynomial_list {
-  friend inline pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr);
-  friend inline pw_qpolynomial_list manage_copy(__isl_keep isl_pw_qpolynomial_list *ptr);
-
-  isl_pw_qpolynomial_list *ptr = nullptr;
-
-  inline explicit pw_qpolynomial_list(__isl_take isl_pw_qpolynomial_list *ptr);
-
-public:
-  inline /* implicit */ pw_qpolynomial_list();
-  inline /* implicit */ pw_qpolynomial_list(const pw_qpolynomial_list &obj);
-  inline pw_qpolynomial_list &operator=(pw_qpolynomial_list obj);
-  inline ~pw_qpolynomial_list();
-  inline __isl_give isl_pw_qpolynomial_list *copy() const &;
-  inline __isl_give isl_pw_qpolynomial_list *copy() && = delete;
-  inline __isl_keep isl_pw_qpolynomial_list *get() const;
-  inline __isl_give isl_pw_qpolynomial_list *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::pw_qpolynomial_list add(isl::pw_qpolynomial el) const;
-  static inline isl::pw_qpolynomial_list alloc(isl::ctx ctx, int n);
-  inline isl::pw_qpolynomial_list clear() const;
-  inline isl::pw_qpolynomial_list concat(isl::pw_qpolynomial_list list2) const;
-  inline isl::pw_qpolynomial_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(pw_qpolynomial)> &fn) const;
-  static inline isl::pw_qpolynomial_list from_pw_qpolynomial(isl::pw_qpolynomial el);
-  inline isl::pw_qpolynomial get_at(int index) const;
-  inline isl::pw_qpolynomial get_pw_qpolynomial(int index) const;
-  inline isl::pw_qpolynomial_list insert(unsigned int pos, isl::pw_qpolynomial el) const;
-  inline isl_size n_pw_qpolynomial() const;
-  inline isl::pw_qpolynomial_list reverse() const;
-  inline isl::pw_qpolynomial_list set_pw_qpolynomial(int index, isl::pw_qpolynomial el) const;
-  inline isl_size size() const;
-  inline isl::pw_qpolynomial_list swap(unsigned int pos1, unsigned int pos2) const;
-};
-
-// declarations for isl::qpolynomial
-inline qpolynomial manage(__isl_take isl_qpolynomial *ptr);
-inline qpolynomial manage_copy(__isl_keep isl_qpolynomial *ptr);
-
-class qpolynomial {
-  friend inline qpolynomial manage(__isl_take isl_qpolynomial *ptr);
-  friend inline qpolynomial manage_copy(__isl_keep isl_qpolynomial *ptr);
-
-  isl_qpolynomial *ptr = nullptr;
-
-  inline explicit qpolynomial(__isl_take isl_qpolynomial *ptr);
-
-public:
-  inline /* implicit */ qpolynomial();
-  inline /* implicit */ qpolynomial(const qpolynomial &obj);
-  inline qpolynomial &operator=(qpolynomial obj);
-  inline ~qpolynomial();
-  inline __isl_give isl_qpolynomial *copy() const &;
-  inline __isl_give isl_qpolynomial *copy() && = delete;
-  inline __isl_keep isl_qpolynomial *get() const;
-  inline __isl_give isl_qpolynomial *release();
-  inline bool is_null() const;
-  inline isl::ctx 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 stat as_polynomial_on_domain(const isl::basic_set &bset, const std::function<stat(basic_set, qpolynomial)> &fn) const;
-  inline isl_size 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 stat foreach_term(const std::function<stat(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 domain);
-  inline isl::qpolynomial insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
-  inline boolean is_infty() const;
-  inline boolean is_nan() const;
-  inline boolean is_neginfty() const;
-  inline boolean is_zero() 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 domain);
-  inline isl::qpolynomial neg() const;
-  static inline isl::qpolynomial neginfty_on_domain(isl::space domain);
-  static inline isl::qpolynomial one_on_domain(isl::space domain);
-  inline boolean plain_is_equal(const isl::qpolynomial &qp2) 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 domain, isl::dim type, unsigned int pos);
-  static inline isl::qpolynomial zero_on_domain(isl::space domain);
-};
-
-// declarations for isl::qpolynomial_list
-inline qpolynomial_list manage(__isl_take isl_qpolynomial_list *ptr);
-inline qpolynomial_list manage_copy(__isl_keep isl_qpolynomial_list *ptr);
-
-class qpolynomial_list {
-  friend inline qpolynomial_list manage(__isl_take isl_qpolynomial_list *ptr);
-  friend inline qpolynomial_list manage_copy(__isl_keep isl_qpolynomial_list *ptr);
-
-  isl_qpolynomial_list *ptr = nullptr;
-
-  inline explicit qpolynomial_list(__isl_take isl_qpolynomial_list *ptr);
-
-public:
-  inline /* implicit */ qpolynomial_list();
-  inline /* implicit */ qpolynomial_list(const qpolynomial_list &obj);
-  inline qpolynomial_list &operator=(qpolynomial_list obj);
-  inline ~qpolynomial_list();
-  inline __isl_give isl_qpolynomial_list *copy() const &;
-  inline __isl_give isl_qpolynomial_list *copy() && = delete;
-  inline __isl_keep isl_qpolynomial_list *get() const;
-  inline __isl_give isl_qpolynomial_list *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::qpolynomial_list add(isl::qpolynomial el) const;
-  static inline isl::qpolynomial_list alloc(isl::ctx ctx, int n);
-  inline isl::qpolynomial_list clear() const;
-  inline isl::qpolynomial_list concat(isl::qpolynomial_list list2) const;
-  inline isl::qpolynomial_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(qpolynomial)> &fn) const;
-  static inline isl::qpolynomial_list from_qpolynomial(isl::qpolynomial el);
-  inline isl::qpolynomial get_at(int index) const;
-  inline isl::qpolynomial get_qpolynomial(int index) const;
-  inline isl::qpolynomial_list insert(unsigned int pos, isl::qpolynomial el) const;
-  inline isl_size n_qpolynomial() const;
-  inline isl::qpolynomial_list reverse() const;
-  inline isl::qpolynomial_list set_qpolynomial(int index, isl::qpolynomial el) const;
-  inline isl_size size() const;
-  inline isl::qpolynomial_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
 };
 
 // declarations for isl::schedule
 inline schedule manage(__isl_take isl_schedule *ptr);
 inline schedule manage_copy(__isl_keep isl_schedule *ptr);
 
 class schedule {
   friend inline schedule manage(__isl_take isl_schedule *ptr);
   friend inline schedule manage_copy(__isl_keep isl_schedule *ptr);
 
+protected:
   isl_schedule *ptr = nullptr;
 
   inline explicit schedule(__isl_take isl_schedule *ptr);
 
 public:
   inline /* implicit */ schedule();
   inline /* implicit */ schedule(const schedule &obj);
   inline explicit schedule(isl::ctx ctx, const std::string &str);
   inline schedule &operator=(schedule obj);
   inline ~schedule();
   inline __isl_give isl_schedule *copy() const &;
   inline __isl_give isl_schedule *copy() && = delete;
   inline __isl_keep isl_schedule *get() const;
   inline __isl_give isl_schedule *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::schedule align_params(isl::space space) const;
-  static inline isl::schedule empty(isl::space space);
-  static inline isl::schedule from_domain(isl::union_set domain);
+  inline isl::union_set domain() const;
   inline isl::union_set get_domain() const;
-  inline isl::union_map get_map() const;
-  inline isl::schedule_node get_root() const;
+  static inline isl::schedule from_domain(isl::union_set domain);
   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 boolean plain_is_equal(const isl::schedule &schedule2) const;
+  inline isl::union_map map() const;
+  inline isl::union_map get_map() const;
   inline isl::schedule pullback(isl::union_pw_multi_aff upma) const;
-  inline isl::schedule reset_user() const;
+  inline isl::schedule_node root() const;
+  inline isl::schedule_node get_root() const;
   inline isl::schedule sequence(isl::schedule schedule2) const;
 };
 
 // declarations for isl::schedule_constraints
 inline schedule_constraints manage(__isl_take isl_schedule_constraints *ptr);
 inline schedule_constraints manage_copy(__isl_keep isl_schedule_constraints *ptr);
 
 class schedule_constraints {
   friend inline schedule_constraints manage(__isl_take isl_schedule_constraints *ptr);
   friend inline schedule_constraints manage_copy(__isl_keep isl_schedule_constraints *ptr);
 
+protected:
   isl_schedule_constraints *ptr = nullptr;
 
   inline explicit schedule_constraints(__isl_take isl_schedule_constraints *ptr);
 
 public:
   inline /* implicit */ schedule_constraints();
   inline /* implicit */ schedule_constraints(const schedule_constraints &obj);
   inline explicit schedule_constraints(isl::ctx ctx, const std::string &str);
   inline schedule_constraints &operator=(schedule_constraints obj);
   inline ~schedule_constraints();
   inline __isl_give isl_schedule_constraints *copy() const &;
   inline __isl_give isl_schedule_constraints *copy() && = delete;
   inline __isl_keep isl_schedule_constraints *get() const;
   inline __isl_give isl_schedule_constraints *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::schedule_constraints apply(isl::union_map umap) const;
-  inline isl::schedule compute_schedule() const;
+  inline isl::union_map coincidence() const;
   inline isl::union_map get_coincidence() const;
+  inline isl::schedule compute_schedule() const;
+  inline isl::union_map conditional_validity() const;
   inline isl::union_map get_conditional_validity() const;
+  inline isl::union_map conditional_validity_condition() const;
   inline isl::union_map get_conditional_validity_condition() const;
+  inline isl::set context() const;
   inline isl::set get_context() const;
+  inline isl::union_set domain() const;
   inline isl::union_set get_domain() const;
-  inline isl::union_map get_proximity() const;
-  inline isl::union_map get_validity() const;
   static inline isl::schedule_constraints on_domain(isl::union_set domain);
+  inline isl::union_map proximity() const;
+  inline isl::union_map get_proximity() const;
   inline isl::schedule_constraints set_coincidence(isl::union_map coincidence) const;
   inline isl::schedule_constraints set_conditional_validity(isl::union_map condition, isl::union_map validity) const;
   inline isl::schedule_constraints set_context(isl::set context) const;
   inline isl::schedule_constraints set_proximity(isl::union_map proximity) const;
   inline isl::schedule_constraints set_validity(isl::union_map validity) const;
+  inline isl::union_map validity() const;
+  inline isl::union_map get_validity() const;
 };
 
 // declarations for isl::schedule_node
 inline schedule_node manage(__isl_take isl_schedule_node *ptr);
 inline schedule_node manage_copy(__isl_keep isl_schedule_node *ptr);
 
 class schedule_node {
   friend inline schedule_node manage(__isl_take isl_schedule_node *ptr);
   friend inline schedule_node manage_copy(__isl_keep isl_schedule_node *ptr);
 
+protected:
   isl_schedule_node *ptr = nullptr;
 
   inline explicit schedule_node(__isl_take isl_schedule_node *ptr);
 
 public:
   inline /* implicit */ schedule_node();
   inline /* implicit */ schedule_node(const schedule_node &obj);
   inline schedule_node &operator=(schedule_node obj);
   inline ~schedule_node();
   inline __isl_give isl_schedule_node *copy() const &;
   inline __isl_give isl_schedule_node *copy() && = delete;
   inline __isl_keep isl_schedule_node *get() const;
   inline __isl_give isl_schedule_node *release();
   inline bool is_null() const;
+private:
+  template <typename T,
+          typename = typename std::enable_if<std::is_same<
+                  const decltype(isl_schedule_node_get_type(NULL)),
+                  const T>::value>::type>
+  inline boolean isa_type(T subtype) const;
+public:
+  template <class T> inline boolean isa() const;
+  template <class T> inline T as() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
-  inline isl::schedule_node align_params(isl::space space) const;
   inline isl::schedule_node ancestor(int generation) const;
-  inline boolean band_member_get_coincident(int pos) 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 class size ancestor_child_position(const isl::schedule_node &ancestor) const;
+  inline class size get_ancestor_child_position(const isl::schedule_node &ancestor) 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 class size child_position() const;
+  inline class size get_child_position() const;
+  inline isl::union_set domain() const;
+  inline isl::union_set get_domain() const;
+  inline boolean every_descendant(const std::function<boolean(isl::schedule_node)> &test) const;
   inline isl::schedule_node first_child() const;
-  inline stat foreach_ancestor_top_down(const std::function<stat(schedule_node)> &fn) const;
+  inline stat foreach_ancestor_top_down(const std::function<stat(isl::schedule_node)> &fn) const;
+  inline stat foreach_descendant_top_down(const std::function<boolean(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 isl_size get_ancestor_child_position(const isl::schedule_node &ancestor) const;
-  inline isl::schedule_node get_child(int pos) const;
-  inline isl_size 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 isl_size 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 isl_size 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 boolean has_children() const;
   inline boolean has_next_sibling() const;
   inline boolean has_parent() const;
   inline boolean has_previous_sibling() 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_mark(const std::string &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 boolean is_equal(const isl::schedule_node &node2) const;
   inline boolean is_subtree_anchored() const;
-  inline isl::id mark_get_id() const;
-  inline isl_size n_children() const;
+  inline isl::schedule_node map_descendant_bottom_up(const std::function<isl::schedule_node(isl::schedule_node)> &fn) const;
+  inline class size 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::multi_union_pw_aff prefix_schedule_multi_union_pw_aff() const;
+  inline isl::multi_union_pw_aff get_prefix_schedule_multi_union_pw_aff() const;
+  inline isl::union_map prefix_schedule_relation() const;
+  inline isl::union_map get_prefix_schedule_relation() const;
+  inline isl::union_map prefix_schedule_union_map() const;
+  inline isl::union_map get_prefix_schedule_union_map() const;
+  inline isl::union_pw_multi_aff prefix_schedule_union_pw_multi_aff() const;
+  inline isl::union_pw_multi_aff get_prefix_schedule_union_pw_multi_aff() const;
   inline isl::schedule_node previous_sibling() const;
-  inline isl::schedule_node reset_user() const;
   inline isl::schedule_node root() const;
-  inline isl::schedule_node sequence_splice_child(int pos) const;
+  inline isl::schedule schedule() const;
+  inline isl::schedule get_schedule() const;
+  inline class size schedule_depth() const;
+  inline class size get_schedule_depth() const;
+  inline isl::schedule_node shared_ancestor(const isl::schedule_node &node2) const;
+  inline isl::schedule_node get_shared_ancestor(const isl::schedule_node &node2) const;
+  inline class size tree_depth() const;
+  inline class size get_tree_depth() const;
+  inline isl::union_set universe_domain() const;
+  inline isl::union_set get_universe_domain() const;
+};
+
+// declarations for isl::schedule_node_band
+
+class schedule_node_band : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_band schedule_node::as<schedule_node_band>() const;
+  static const auto type = isl_schedule_node_band;
+
+protected:
+  inline explicit schedule_node_band(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_band();
+  inline /* implicit */ schedule_node_band(const schedule_node_band &obj);
+  inline schedule_node_band &operator=(schedule_node_band obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::union_set ast_build_options() const;
+  inline isl::union_set get_ast_build_options() const;
+  inline isl::set ast_isolate_option() const;
+  inline isl::set get_ast_isolate_option() const;
+  inline boolean member_get_coincident(int pos) const;
+  inline schedule_node_band member_set_coincident(int pos, int coincident) const;
+  inline schedule_node_band mod(isl::multi_val mv) const;
+  inline class size n_member() const;
+  inline isl::multi_union_pw_aff partial_schedule() const;
+  inline isl::multi_union_pw_aff get_partial_schedule() const;
+  inline boolean permutable() const;
+  inline boolean get_permutable() const;
+  inline schedule_node_band scale(isl::multi_val mv) const;
+  inline schedule_node_band scale_down(isl::multi_val mv) const;
+  inline schedule_node_band set_ast_build_options(isl::union_set options) const;
+  inline schedule_node_band set_permutable(int permutable) const;
+  inline schedule_node_band shift(isl::multi_union_pw_aff shift) const;
+  inline schedule_node_band split(int pos) const;
+  inline schedule_node_band tile(isl::multi_val sizes) const;
+  inline schedule_node_band member_set_ast_loop_default(int pos) const;
+  inline schedule_node_band member_set_ast_loop_atomic(int pos) const;
+  inline schedule_node_band member_set_ast_loop_unroll(int pos) const;
+  inline schedule_node_band member_set_ast_loop_separate(int pos) const;
+};
+
+// declarations for isl::schedule_node_context
+
+class schedule_node_context : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_context schedule_node::as<schedule_node_context>() const;
+  static const auto type = isl_schedule_node_context;
+
+protected:
+  inline explicit schedule_node_context(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_context();
+  inline /* implicit */ schedule_node_context(const schedule_node_context &obj);
+  inline schedule_node_context &operator=(schedule_node_context obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::set context() const;
+  inline isl::set get_context() const;
+};
+
+// declarations for isl::schedule_node_domain
+
+class schedule_node_domain : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_domain schedule_node::as<schedule_node_domain>() const;
+  static const auto type = isl_schedule_node_domain;
+
+protected:
+  inline explicit schedule_node_domain(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_domain();
+  inline /* implicit */ schedule_node_domain(const schedule_node_domain &obj);
+  inline schedule_node_domain &operator=(schedule_node_domain obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::union_set domain() const;
+  inline isl::union_set get_domain() const;
+};
+
+// declarations for isl::schedule_node_expansion
+
+class schedule_node_expansion : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_expansion schedule_node::as<schedule_node_expansion>() const;
+  static const auto type = isl_schedule_node_expansion;
+
+protected:
+  inline explicit schedule_node_expansion(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_expansion();
+  inline /* implicit */ schedule_node_expansion(const schedule_node_expansion &obj);
+  inline schedule_node_expansion &operator=(schedule_node_expansion obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::union_pw_multi_aff contraction() const;
+  inline isl::union_pw_multi_aff get_contraction() const;
+  inline isl::union_map expansion() const;
+  inline isl::union_map get_expansion() const;
+};
+
+// declarations for isl::schedule_node_extension
+
+class schedule_node_extension : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_extension schedule_node::as<schedule_node_extension>() const;
+  static const auto type = isl_schedule_node_extension;
+
+protected:
+  inline explicit schedule_node_extension(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_extension();
+  inline /* implicit */ schedule_node_extension(const schedule_node_extension &obj);
+  inline schedule_node_extension &operator=(schedule_node_extension obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::union_map extension() const;
+  inline isl::union_map get_extension() const;
+};
+
+// declarations for isl::schedule_node_filter
+
+class schedule_node_filter : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_filter schedule_node::as<schedule_node_filter>() const;
+  static const auto type = isl_schedule_node_filter;
+
+protected:
+  inline explicit schedule_node_filter(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_filter();
+  inline /* implicit */ schedule_node_filter(const schedule_node_filter &obj);
+  inline schedule_node_filter &operator=(schedule_node_filter obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::union_set filter() const;
+  inline isl::union_set get_filter() const;
+};
+
+// declarations for isl::schedule_node_guard
+
+class schedule_node_guard : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_guard schedule_node::as<schedule_node_guard>() const;
+  static const auto type = isl_schedule_node_guard;
+
+protected:
+  inline explicit schedule_node_guard(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_guard();
+  inline /* implicit */ schedule_node_guard(const schedule_node_guard &obj);
+  inline schedule_node_guard &operator=(schedule_node_guard obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::set guard() const;
+  inline isl::set get_guard() const;
+};
+
+// declarations for isl::schedule_node_leaf
+
+class schedule_node_leaf : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_leaf schedule_node::as<schedule_node_leaf>() const;
+  static const auto type = isl_schedule_node_leaf;
+
+protected:
+  inline explicit schedule_node_leaf(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_leaf();
+  inline /* implicit */ schedule_node_leaf(const schedule_node_leaf &obj);
+  inline schedule_node_leaf &operator=(schedule_node_leaf obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::schedule_node_mark
+
+class schedule_node_mark : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_mark schedule_node::as<schedule_node_mark>() const;
+  static const auto type = isl_schedule_node_mark;
+
+protected:
+  inline explicit schedule_node_mark(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_mark();
+  inline /* implicit */ schedule_node_mark(const schedule_node_mark &obj);
+  inline schedule_node_mark &operator=(schedule_node_mark obj);
+  inline isl::ctx ctx() const;
+
+  inline isl::id id() const;
+  inline isl::id get_id() const;
+};
+
+// declarations for isl::schedule_node_sequence
+
+class schedule_node_sequence : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_sequence schedule_node::as<schedule_node_sequence>() const;
+  static const auto type = isl_schedule_node_sequence;
+
+protected:
+  inline explicit schedule_node_sequence(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_sequence();
+  inline /* implicit */ schedule_node_sequence(const schedule_node_sequence &obj);
+  inline schedule_node_sequence &operator=(schedule_node_sequence obj);
+  inline isl::ctx ctx() const;
+
+};
+
+// declarations for isl::schedule_node_set
+
+class schedule_node_set : public schedule_node {
+  template <class T>
+  friend boolean schedule_node::isa() const;
+  friend schedule_node_set schedule_node::as<schedule_node_set>() const;
+  static const auto type = isl_schedule_node_set;
+
+protected:
+  inline explicit schedule_node_set(__isl_take isl_schedule_node *ptr);
+
+public:
+  inline /* implicit */ schedule_node_set();
+  inline /* implicit */ schedule_node_set(const schedule_node_set &obj);
+  inline schedule_node_set &operator=(schedule_node_set obj);
+  inline isl::ctx ctx() const;
+
 };
 
 // declarations for isl::set
 inline set manage(__isl_take isl_set *ptr);
 inline set manage_copy(__isl_keep isl_set *ptr);
 
 class set {
   friend inline set manage(__isl_take isl_set *ptr);
   friend inline set manage_copy(__isl_keep isl_set *ptr);
 
+protected:
   isl_set *ptr = nullptr;
 
   inline explicit set(__isl_take isl_set *ptr);
 
 public:
   inline /* implicit */ set();
   inline /* implicit */ set(const set &obj);
   inline /* implicit */ set(isl::basic_set bset);
   inline /* implicit */ set(isl::point pnt);
   inline explicit set(isl::union_set uset);
   inline explicit set(isl::ctx ctx, const std::string &str);
   inline set &operator=(set obj);
   inline ~set();
   inline __isl_give isl_set *copy() const &;
   inline __isl_give isl_set *copy() && = delete;
   inline __isl_keep isl_set *get() const;
   inline __isl_give isl_set *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::set add_constraint(isl::constraint constraint) const;
   inline isl::set add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_set affine_hull() const;
   inline isl::set align_params(isl::space model) const;
   inline isl::set apply(isl::map map) const;
+  inline isl::union_set apply(const isl::union_map &umap) const;
+  inline isl::set apply(const isl::basic_map &map) const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::set as_set() const;
+  inline isl::basic_set_list basic_set_list() const;
+  inline isl::basic_set_list get_basic_set_list() const;
   inline isl::set bind(isl::multi_id tuple) const;
-  inline isl::basic_set bounded_simple_hull() const;
-  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::union_set compute_divs() const;
+  inline boolean contains(const isl::space &space) const;
   inline isl::basic_set convex_hull() const;
-  inline isl::val count_val() const;
   inline isl::set detect_equalities() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
   inline boolean dim_has_any_lower_bound(isl::dim type, unsigned int pos) const;
-  inline boolean dim_has_any_upper_bound(isl::dim type, unsigned int pos) const;
-  inline boolean dim_has_lower_bound(isl::dim type, unsigned int pos) const;
-  inline boolean dim_has_upper_bound(isl::dim type, unsigned int pos) const;
-  inline boolean dim_is_bounded(isl::dim type, unsigned int pos) const;
+  inline isl::id dim_id(isl::dim type, unsigned int pos) const;
+  inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::pw_aff dim_max(int pos) const;
   inline isl::val dim_max_val(int pos) const;
   inline isl::pw_aff dim_min(int pos) const;
   inline isl::val dim_min_val(int pos) const;
+  inline std::string dim_name(isl::dim type, unsigned int pos) const;
+  inline std::string get_dim_name(isl::dim type, unsigned 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 boolean every_set(const std::function<boolean(isl::set)> &test) const;
+  inline isl::set extract_set(const isl::space &space) 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 int find_dim_by_id(isl::dim type, const std::string &id) 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 stat foreach_basic_set(const std::function<stat(basic_set)> &fn) const;
-  inline stat foreach_point(const std::function<stat(point)> &fn) const;
-  static inline isl::set from_multi_aff(isl::multi_aff ma);
-  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::multi_val get_plain_multi_val_if_fixed() const;
-  inline isl::fixed_box get_simple_fixed_box_hull() 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 stat foreach_basic_set(const std::function<stat(isl::basic_set)> &fn) const;
+  inline stat foreach_point(const std::function<stat(isl::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::set)> &fn) const;
   inline isl::set gist(isl::set context) const;
-  inline isl::set gist_basic_set(isl::basic_set context) const;
+  inline isl::union_set gist(const isl::union_set &context) const;
+  inline isl::set gist(const isl::basic_set &context) const;
+  inline isl::set gist(const isl::point &context) const;
   inline isl::set gist_params(isl::set context) const;
-  inline boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
   inline boolean has_equal_space(const isl::set &set2) const;
-  inline boolean has_tuple_id() const;
-  inline boolean has_tuple_name() const;
   inline isl::map identity() const;
+  inline isl::union_pw_multi_aff identity_union_pw_multi_aff() 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::map insert_domain(isl::space domain) const;
   inline isl::set intersect(isl::set set2) const;
-  inline isl::set intersect_factor_domain(isl::set domain) const;
-  inline isl::set intersect_factor_range(isl::set range) const;
+  inline isl::union_set intersect(const isl::union_set &uset2) const;
+  inline isl::set intersect(const isl::basic_set &set2) const;
+  inline isl::set intersect(const isl::point &set2) const;
   inline isl::set intersect_params(isl::set params) const;
   inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline boolean involves_locals() const;
   inline boolean is_bounded() const;
-  inline boolean is_box() const;
   inline boolean is_disjoint(const isl::set &set2) const;
+  inline boolean is_disjoint(const isl::union_set &uset2) const;
+  inline boolean is_disjoint(const isl::basic_set &set2) const;
+  inline boolean is_disjoint(const isl::point &set2) const;
   inline boolean is_empty() const;
   inline boolean is_equal(const isl::set &set2) const;
+  inline boolean is_equal(const isl::union_set &uset2) const;
+  inline boolean is_equal(const isl::basic_set &set2) const;
+  inline boolean is_equal(const isl::point &set2) const;
   inline boolean is_params() const;
   inline boolean is_singleton() const;
   inline boolean is_strict_subset(const isl::set &set2) const;
+  inline boolean is_strict_subset(const isl::union_set &uset2) const;
+  inline boolean is_strict_subset(const isl::basic_set &set2) const;
+  inline boolean is_strict_subset(const isl::point &set2) const;
   inline boolean is_subset(const isl::set &set2) const;
+  inline boolean is_subset(const isl::union_set &uset2) const;
+  inline boolean is_subset(const isl::basic_set &set2) const;
+  inline boolean is_subset(const isl::point &set2) const;
   inline boolean is_wrapping() 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_lt_set(isl::set set2) const;
+  inline boolean isa_set() 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(isl::multi_pw_aff lower) const;
   inline isl::set lower_bound(isl::multi_val lower) 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::set lower_bound_val(isl::dim type, unsigned int pos, long value) const;
   inline isl::multi_pw_aff max_multi_pw_aff() const;
   inline isl::val max_val(const isl::aff &obj) const;
   inline isl::multi_pw_aff min_multi_pw_aff() 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 isl_size n_basic_set() const;
-  inline isl_size n_dim() const;
-  static inline isl::set nat_universe(isl::space space);
-  inline isl::set neg() const;
+  inline class size n_basic_set() 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 boolean plain_is_disjoint(const isl::set &set2) const;
-  inline boolean plain_is_empty() const;
-  inline boolean plain_is_equal(const isl::set &set2) const;
-  inline boolean plain_is_universe() const;
-  inline isl::basic_set plain_unshifted_simple_hull() const;
+  inline isl::multi_val plain_multi_val_if_fixed() const;
+  inline isl::multi_val get_plain_multi_val_if_fixed() const;
   inline isl::basic_set polyhedral_hull() const;
   inline isl::set preimage(isl::multi_aff ma) const;
   inline isl::set preimage(isl::multi_pw_aff mpa) const;
   inline isl::set preimage(isl::pw_multi_aff pma) const;
+  inline isl::union_set preimage(const isl::union_pw_multi_aff &upma) 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;
   inline isl::set project_out_all_params() const;
   inline isl::set project_out_param(isl::id id) const;
+  inline isl::set project_out_param(const std::string &id) const;
   inline isl::set project_out_param(isl::id_list list) const;
+  inline isl::pw_multi_aff pw_multi_aff_on_domain(isl::multi_val mv) const;
   inline isl::set remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set remove_divs() const;
-  inline isl::set remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::set remove_redundancies() const;
-  inline isl::set remove_unknown_divs() const;
-  inline isl::set reset_space(isl::space space) const;
   inline isl::set reset_tuple_id() const;
-  inline isl::set reset_user() const;
   inline isl::basic_set sample() const;
   inline isl::point sample_point() const;
   inline isl::set set_dim_id(isl::dim type, unsigned int pos, isl::id id) const;
+  inline isl::set set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const;
+  inline isl::set_list set_list() const;
   inline isl::set set_tuple_id(isl::id id) const;
-  inline isl::set set_tuple_name(const std::string &s) const;
+  inline isl::set set_tuple_id(const std::string &id) const;
+  inline isl::fixed_box simple_fixed_box_hull() const;
+  inline isl::fixed_box get_simple_fixed_box_hull() const;
   inline isl::basic_set simple_hull() const;
-  inline int size() const;
-  inline isl::basic_set solutions() const;
-  inline isl::set split_dims(isl::dim type, unsigned int first, unsigned int n) const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
+  inline isl::val stride(int pos) const;
+  inline isl::val get_stride(int pos) const;
   inline isl::set subtract(isl::set set2) const;
-  inline isl::set sum(isl::set set2) const;
+  inline isl::union_set subtract(const isl::union_set &uset2) const;
+  inline isl::set subtract(const isl::basic_set &set2) const;
+  inline isl::set subtract(const isl::point &set2) const;
+  inline isl::set_list to_list() const;
+  inline isl::union_set to_union_set() const;
   inline isl::map translation() const;
-  inline isl_size tuple_dim() const;
+  inline class size tuple_dim() const;
+  inline isl::id tuple_id() const;
+  inline isl::id get_tuple_id() const;
+  inline std::string tuple_name() const;
+  inline std::string get_tuple_name() const;
   inline isl::set unbind_params(isl::multi_id tuple) const;
   inline isl::map unbind_params_insert_domain(isl::multi_id domain) const;
   inline isl::set unite(isl::set set2) const;
+  inline isl::union_set unite(const isl::union_set &uset2) const;
+  inline isl::set unite(const isl::basic_set &set2) const;
+  inline isl::set unite(const isl::point &set2) const;
   static inline isl::set universe(isl::space space);
   inline isl::basic_set unshifted_simple_hull() const;
-  inline isl::basic_set unshifted_simple_hull_from_set_list(isl::set_list list) const;
   inline isl::map unwrap() const;
   inline isl::set upper_bound(isl::multi_pw_aff upper) const;
   inline isl::set upper_bound(isl::multi_val upper) const;
-  inline isl::set upper_bound_si(isl::dim type, unsigned int pos, int value) const;
   inline isl::set upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const;
-  inline isl::map wrapped_domain_map() const;
+  inline isl::set upper_bound_val(isl::dim type, unsigned int pos, long value) const;
 };
 
 // declarations for isl::set_list
 inline set_list manage(__isl_take isl_set_list *ptr);
 inline set_list manage_copy(__isl_keep isl_set_list *ptr);
 
 class set_list {
   friend inline set_list manage(__isl_take isl_set_list *ptr);
   friend inline set_list manage_copy(__isl_keep isl_set_list *ptr);
 
+protected:
   isl_set_list *ptr = nullptr;
 
   inline explicit set_list(__isl_take isl_set_list *ptr);
 
 public:
   inline /* implicit */ set_list();
   inline /* implicit */ set_list(const set_list &obj);
+  inline explicit set_list(isl::ctx ctx, int n);
+  inline explicit set_list(isl::set el);
+  inline explicit set_list(isl::ctx ctx, const std::string &str);
   inline set_list &operator=(set_list obj);
   inline ~set_list();
   inline __isl_give isl_set_list *copy() const &;
   inline __isl_give isl_set_list *copy() && = delete;
   inline __isl_keep isl_set_list *get() const;
   inline __isl_give isl_set_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::set_list add(isl::set el) const;
-  static inline isl::set_list alloc(isl::ctx ctx, int n);
+  inline isl::set at(int index) const;
+  inline isl::set get_at(int index) const;
   inline isl::set_list clear() const;
   inline isl::set_list concat(isl::set_list list2) const;
   inline isl::set_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(set)> &fn) const;
-  static inline isl::set_list from_set(isl::set el);
-  inline isl::set get_at(int index) const;
-  inline isl::set get_set(int index) const;
+  inline stat foreach(const std::function<stat(isl::set)> &fn) const;
   inline isl::set_list insert(unsigned int pos, isl::set el) const;
-  inline isl_size n_set() const;
-  inline isl::set_list reverse() const;
-  inline isl::set_list set_set(int index, isl::set el) const;
-  inline isl_size size() const;
-  inline isl::set_list swap(unsigned int pos1, unsigned int pos2) const;
-  inline isl::set unite() const;
+  inline class size size() const;
 };
 
 // declarations for isl::space
 inline space manage(__isl_take isl_space *ptr);
 inline space manage_copy(__isl_keep isl_space *ptr);
 
 class space {
   friend inline space manage(__isl_take isl_space *ptr);
   friend inline space manage_copy(__isl_keep isl_space *ptr);
 
+protected:
   isl_space *ptr = nullptr;
 
   inline explicit space(__isl_take isl_space *ptr);
 
 public:
   inline /* implicit */ space();
   inline /* implicit */ space(const space &obj);
   inline explicit space(isl::ctx ctx, unsigned int nparam, unsigned int n_in, unsigned int n_out);
   inline explicit space(isl::ctx ctx, unsigned int nparam, unsigned int dim);
   inline space &operator=(space obj);
   inline ~space();
   inline __isl_give isl_space *copy() const &;
   inline __isl_give isl_space *copy() && = delete;
   inline __isl_keep isl_space *get() const;
   inline __isl_give isl_space *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::space add_dims(isl::dim type, unsigned int n) const;
   inline isl::space add_named_tuple(isl::id tuple_id, unsigned int dim) const;
-  inline isl::space add_param_id(isl::id id) const;
+  inline isl::space add_named_tuple(const std::string &tuple_id, unsigned int dim) const;
+  inline isl::space add_param(isl::id id) const;
+  inline isl::space add_param(const std::string &id) const;
   inline isl::space add_unnamed_tuple(unsigned int dim) const;
   inline isl::space align_params(isl::space space2) const;
-  inline boolean can_curry() const;
-  inline boolean can_range_curry() const;
-  inline boolean can_uncurry() const;
-  inline boolean can_zip() const;
   inline isl::space curry() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size dim(isl::dim type) const;
+  inline isl::id dim_id(isl::dim type, unsigned int pos) const;
+  inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space domain() const;
-  inline isl::space domain_factor_domain() const;
-  inline isl::space domain_factor_range() const;
-  inline boolean domain_is_wrapping() const;
-  inline isl::space domain_map() const;
-  inline isl::space domain_product(isl::space right) const;
-  inline isl::space drop_all_params() const;
+  inline isl::multi_aff domain_map_multi_aff() const;
+  inline isl::pw_multi_aff domain_map_pw_multi_aff() const;
+  inline isl::id domain_tuple_id() const;
+  inline isl::id get_domain_tuple_id() 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 int find_dim_by_id(isl::dim type, const std::string &id) 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 boolean has_dim_id(isl::dim type, unsigned int pos) const;
-  inline boolean has_dim_name(isl::dim type, unsigned int pos) const;
-  inline boolean has_equal_params(const isl::space &space2) const;
+  inline boolean has_domain_tuple_id() const;
   inline boolean has_equal_tuples(const isl::space &space2) const;
+  inline boolean has_range_tuple_id() const;
   inline boolean has_tuple_id(isl::dim type) const;
   inline boolean has_tuple_name(isl::dim type) const;
-  inline isl::space insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
-  inline boolean is_domain(const isl::space &space2) const;
+  inline isl::multi_aff identity_multi_aff_on_domain() const;
+  inline isl::multi_pw_aff identity_multi_pw_aff_on_domain() const;
+  inline isl::pw_multi_aff identity_pw_multi_aff_on_domain() const;
   inline boolean is_equal(const isl::space &space2) const;
-  inline boolean is_map() const;
   inline boolean is_params() const;
-  inline boolean is_product() const;
-  inline boolean is_range(const isl::space &space2) const;
   inline boolean is_set() const;
   inline boolean is_wrapping() 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::multi_aff multi_aff(isl::aff_list list) const;
+  inline isl::multi_aff multi_aff_on_domain(isl::multi_val mv) const;
+  inline isl::multi_id multi_id(isl::id_list list) const;
+  inline isl::multi_pw_aff multi_pw_aff(isl::pw_aff_list list) const;
+  inline isl::multi_union_pw_aff multi_union_pw_aff(isl::union_pw_aff_list list) const;
+  inline isl::multi_val multi_val(isl::val_list list) const;
+  inline isl::aff param_aff_on_domain(isl::id id) const;
+  inline isl::aff param_aff_on_domain(const std::string &id) 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 boolean range_is_wrapping() const;
-  inline isl::space range_map() const;
-  inline isl::space range_product(isl::space right) const;
+  inline isl::multi_aff range_map_multi_aff() const;
+  inline isl::pw_multi_aff range_map_pw_multi_aff() const;
   inline isl::space range_reverse() const;
-  inline isl::space reset_tuple_id(isl::dim type) const;
-  inline isl::space reset_user() const;
+  inline isl::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() 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_dim_id(isl::dim type, unsigned int pos, const std::string &id) const;
+  inline isl::space set_domain_tuple(isl::id id) const;
+  inline isl::space set_domain_tuple(const std::string &id) const;
   inline isl::space set_from_params() const;
+  inline isl::space set_range_tuple(isl::id id) const;
+  inline isl::space set_range_tuple(const std::string &id) 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 boolean tuple_is_equal(isl::dim type1, const isl::space &space2, isl::dim type2) const;
+  inline isl::space set_tuple_id(isl::dim type, const std::string &id) const;
+  inline isl::id tuple_id(isl::dim type) const;
+  inline isl::id get_tuple_id(isl::dim type) const;
+  inline std::string tuple_name(isl::dim type) const;
+  inline std::string get_tuple_name(isl::dim type) const;
   inline isl::space uncurry() const;
   static inline isl::space unit(isl::ctx ctx);
+  inline isl::map universe_map() const;
+  inline isl::set universe_set() const;
   inline isl::space unwrap() const;
   inline isl::space wrap() const;
-  inline isl::space zip() const;
-};
-
-// declarations for isl::term
-inline term manage(__isl_take isl_term *ptr);
-inline term manage_copy(__isl_keep isl_term *ptr);
-
-class term {
-  friend inline term manage(__isl_take isl_term *ptr);
-  friend inline term manage_copy(__isl_keep isl_term *ptr);
-
-  isl_term *ptr = nullptr;
-
-  inline explicit term(__isl_take isl_term *ptr);
-
-public:
-  inline /* implicit */ term();
-  inline /* implicit */ term(const term &obj);
-  inline term &operator=(term obj);
-  inline ~term();
-  inline __isl_give isl_term *copy() const &;
-  inline __isl_give isl_term *copy() && = delete;
-  inline __isl_keep isl_term *get() const;
-  inline __isl_give isl_term *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-
-  inline isl_size dim(isl::dim type) const;
-  inline isl::val get_coefficient_val() const;
-  inline isl::aff get_div(unsigned int pos) const;
-  inline isl_size get_exp(isl::dim type, unsigned int pos) const;
+  inline isl::aff zero_aff_on_domain() const;
+  inline isl::multi_aff zero_multi_aff() const;
+  inline isl::multi_pw_aff zero_multi_pw_aff() const;
+  inline isl::multi_union_pw_aff zero_multi_union_pw_aff() const;
+  inline isl::multi_val zero_multi_val() const;
 };
 
 // declarations for isl::union_access_info
 inline union_access_info manage(__isl_take isl_union_access_info *ptr);
 inline union_access_info manage_copy(__isl_keep isl_union_access_info *ptr);
 
 class union_access_info {
   friend inline union_access_info manage(__isl_take isl_union_access_info *ptr);
   friend inline union_access_info manage_copy(__isl_keep isl_union_access_info *ptr);
 
+protected:
   isl_union_access_info *ptr = nullptr;
 
   inline explicit union_access_info(__isl_take isl_union_access_info *ptr);
 
 public:
   inline /* implicit */ union_access_info();
   inline /* implicit */ union_access_info(const union_access_info &obj);
   inline explicit union_access_info(isl::union_map sink);

 // declarations for isl::union_flow
 inline union_flow manage(__isl_take isl_union_flow *ptr);
 inline union_flow manage_copy(__isl_keep isl_union_flow *ptr);
 
 class union_flow {
   friend inline union_flow manage(__isl_take isl_union_flow *ptr);
   friend inline union_flow manage_copy(__isl_keep isl_union_flow *ptr);
 
+protected:
   isl_union_flow *ptr = nullptr;
 
   inline explicit union_flow(__isl_take isl_union_flow *ptr);
 
 public:
   inline /* implicit */ union_flow();
   inline /* implicit */ union_flow(const union_flow &obj);
   inline union_flow &operator=(union_flow obj);
   inline ~union_flow();
   inline __isl_give isl_union_flow *copy() const &;
   inline __isl_give isl_union_flow *copy() && = delete;
   inline __isl_keep isl_union_flow *get() const;
   inline __isl_give isl_union_flow *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
 
+  inline isl::union_map full_may_dependence() const;
   inline isl::union_map get_full_may_dependence() const;
+  inline isl::union_map full_must_dependence() const;
   inline isl::union_map get_full_must_dependence() const;
+  inline isl::union_map may_dependence() const;
   inline isl::union_map get_may_dependence() const;
+  inline isl::union_map may_no_source() const;
   inline isl::union_map get_may_no_source() const;
+  inline isl::union_map must_dependence() const;
   inline isl::union_map get_must_dependence() const;
+  inline isl::union_map must_no_source() const;
   inline isl::union_map get_must_no_source() const;
 };
 
 // declarations for isl::union_map
 inline union_map manage(__isl_take isl_union_map *ptr);
 inline union_map manage_copy(__isl_keep isl_union_map *ptr);
 
 class union_map {
   friend inline union_map manage(__isl_take isl_union_map *ptr);
   friend inline union_map manage_copy(__isl_keep isl_union_map *ptr);
 
+protected:
   isl_union_map *ptr = nullptr;
 
   inline explicit union_map(__isl_take isl_union_map *ptr);
 
 public:
   inline /* implicit */ union_map();
   inline /* implicit */ union_map(const union_map &obj);
   inline /* implicit */ union_map(isl::basic_map bmap);
   inline /* implicit */ union_map(isl::map map);
-  inline explicit union_map(isl::union_pw_multi_aff upma);
   inline explicit union_map(isl::ctx ctx, const std::string &str);
   inline union_map &operator=(union_map obj);
   inline ~union_map();
   inline __isl_give isl_union_map *copy() const &;
   inline __isl_give isl_union_map *copy() && = delete;
   inline __isl_keep isl_union_map *get() const;
   inline __isl_give isl_union_map *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() 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::map as_map() const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::union_pw_multi_aff as_union_pw_multi_aff() const;
   inline isl::union_set bind_range(isl::multi_id tuple) const;
   inline isl::union_map coalesce() const;
-  inline boolean contains(const isl::space &space) const;
+  inline isl::union_map compute_divs() 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 isl_size 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::ctx ctx);
   inline isl::union_map eq_at(isl::multi_union_pw_aff mupa) const;
+  inline boolean every_map(const std::function<boolean(isl::map)> &test) const;
   inline isl::map extract_map(isl::space space) 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 fixed_power(long exp) const;
   inline isl::union_map flat_range_product(isl::union_map umap2) const;
-  inline stat foreach_map(const std::function<stat(map)> &fn) const;
+  inline stat foreach_map(const std::function<stat(isl::map)> &fn) const;
   static inline isl::union_map from(isl::multi_union_pw_aff mupa);
+  static inline isl::union_map from(isl::union_pw_multi_aff upma);
   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);
-  static inline isl::union_map from_union_pw_aff(isl::union_pw_aff upa);
-  inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
-  inline uint32_t get_hash() const;
-  inline isl::map_list get_map_list() 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::space space) const;
   inline isl::union_map intersect_domain(isl::union_set uset) const;
   inline isl::union_map intersect_domain_factor_domain(isl::union_map factor) const;
   inline isl::union_map intersect_domain_factor_range(isl::union_map factor) const;
   inline isl::union_map intersect_params(isl::set set) const;
   inline isl::union_map intersect_range(isl::space space) const;
   inline isl::union_map intersect_range(isl::union_set uset) const;
   inline isl::union_map intersect_range_factor_domain(isl::union_map factor) const;
   inline isl::union_map intersect_range_factor_range(isl::union_map factor) const;
-  inline boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline boolean is_bijective() const;
   inline boolean is_disjoint(const isl::union_map &umap2) const;
   inline boolean is_empty() const;
   inline boolean is_equal(const isl::union_map &umap2) const;
-  inline boolean is_identity() const;
   inline boolean is_injective() const;
   inline boolean is_single_valued() const;
   inline boolean is_strict_subset(const isl::union_map &umap2) const;
   inline boolean is_subset(const isl::union_map &umap2) const;
   inline boolean isa_map() const;
-  inline isl::union_map lex_ge_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) 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_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) 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 isl_size n_map() const;
+  inline isl::map_list map_list() const;
+  inline isl::map_list get_map_list() const;
   inline isl::set params() const;
-  inline boolean plain_is_empty() const;
-  inline boolean plain_is_injective() const;
   inline isl::union_map polyhedral_hull() const;
   inline isl::union_map preimage_domain(isl::multi_aff ma) const;
   inline isl::union_map preimage_domain(isl::multi_pw_aff mpa) const;
   inline isl::union_map preimage_domain(isl::pw_multi_aff pma) const;
   inline isl::union_map preimage_domain(isl::union_pw_multi_aff upma) const;
   inline isl::union_map preimage_range(isl::multi_aff ma) const;
   inline isl::union_map preimage_range(isl::pw_multi_aff pma) const;
   inline isl::union_map preimage_range(isl::union_pw_multi_aff upma) const;
   inline isl::union_map product(isl::union_map umap2) const;
-  inline isl::union_map project_out(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::union_map project_out_all_params() const;
   inline isl::union_set range() const;
-  inline isl::union_map range_curry() const;
   inline isl::union_map range_factor_domain() const;
   inline isl::union_map range_factor_range() const;
   inline isl::union_map range_map() const;
   inline isl::union_map range_product(isl::union_map umap2) const;
   inline isl::union_map range_reverse() const;
-  inline isl::union_map remove_divs() const;
-  inline isl::union_map remove_redundancies() const;
-  inline isl::union_map reset_user() const;
   inline isl::union_map reverse() const;
-  inline isl::basic_map sample() const;
-  inline isl::union_map simple_hull() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::union_map subtract(isl::union_map umap2) const;
   inline isl::union_map subtract_domain(isl::union_set dom) const;
   inline isl::union_map subtract_range(isl::union_set dom) const;
   inline isl::union_map uncurry() const;
   inline isl::union_map unite(isl::union_map umap2) const;
   inline isl::union_map universe() const;
   inline isl::union_set wrap() const;
   inline isl::union_map zip() const;
 };
 
-// declarations for isl::union_map_list
-inline union_map_list manage(__isl_take isl_union_map_list *ptr);
-inline union_map_list manage_copy(__isl_keep isl_union_map_list *ptr);
-
-class union_map_list {
-  friend inline union_map_list manage(__isl_take isl_union_map_list *ptr);
-  friend inline union_map_list manage_copy(__isl_keep isl_union_map_list *ptr);
-
-  isl_union_map_list *ptr = nullptr;
-
-  inline explicit union_map_list(__isl_take isl_union_map_list *ptr);
-
-public:
-  inline /* implicit */ union_map_list();
-  inline /* implicit */ union_map_list(const union_map_list &obj);
-  inline union_map_list &operator=(union_map_list obj);
-  inline ~union_map_list();
-  inline __isl_give isl_union_map_list *copy() const &;
-  inline __isl_give isl_union_map_list *copy() && = delete;
-  inline __isl_keep isl_union_map_list *get() const;
-  inline __isl_give isl_union_map_list *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::union_map_list add(isl::union_map el) const;
-  static inline isl::union_map_list alloc(isl::ctx ctx, int n);
-  inline isl::union_map_list clear() const;
-  inline isl::union_map_list concat(isl::union_map_list list2) const;
-  inline isl::union_map_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(union_map)> &fn) const;
-  static inline isl::union_map_list from_union_map(isl::union_map el);
-  inline isl::union_map get_at(int index) const;
-  inline isl::union_map get_union_map(int index) const;
-  inline isl::union_map_list insert(unsigned int pos, isl::union_map el) const;
-  inline isl_size n_union_map() const;
-  inline isl::union_map_list reverse() const;
-  inline isl::union_map_list set_union_map(int index, isl::union_map el) const;
-  inline isl_size size() const;
-  inline isl::union_map_list swap(unsigned int pos1, unsigned int pos2) const;
-};
-
 // declarations for isl::union_pw_aff
 inline union_pw_aff manage(__isl_take isl_union_pw_aff *ptr);
 inline union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr);
 
 class union_pw_aff {
   friend inline union_pw_aff manage(__isl_take isl_union_pw_aff *ptr);
   friend inline union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr);
 
+protected:
   isl_union_pw_aff *ptr = nullptr;
 
   inline explicit union_pw_aff(__isl_take isl_union_pw_aff *ptr);
 
 public:
   inline /* implicit */ union_pw_aff();
   inline /* implicit */ union_pw_aff(const union_pw_aff &obj);
   inline /* implicit */ union_pw_aff(isl::aff aff);
   inline /* implicit */ union_pw_aff(isl::pw_aff pa);
   inline explicit union_pw_aff(isl::ctx ctx, const std::string &str);
   inline explicit union_pw_aff(isl::union_set domain, isl::val v);
   inline union_pw_aff &operator=(union_pw_aff obj);
   inline ~union_pw_aff();
   inline __isl_give isl_union_pw_aff *copy() const &;
   inline __isl_give isl_union_pw_aff *copy() && = delete;
   inline __isl_keep isl_union_pw_aff *get() const;
   inline __isl_give isl_union_pw_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
+  inline isl::multi_union_pw_aff add(const isl::multi_union_pw_aff &multi2) const;
   inline isl::union_pw_aff add(isl::union_pw_aff upa2) const;
-  inline isl::union_pw_aff add_pw_aff(isl::pw_aff pa) const;
-  static inline isl::union_pw_aff aff_on_domain(isl::union_set domain, isl::aff aff);
-  inline isl::union_pw_aff align_params(isl::space model) const;
+  inline isl::union_pw_multi_aff add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::union_pw_aff add(const isl::aff &upa2) const;
+  inline isl::union_pw_aff add(const isl::pw_aff &upa2) const;
+  inline isl::union_pw_multi_aff add_pw_multi_aff(const isl::pw_multi_aff &pma) const;
+  inline isl::union_pw_multi_aff apply(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::union_map as_union_map() const;
+  inline isl::union_pw_aff at(int pos) const;
+  inline isl::union_set bind(const isl::multi_id &tuple) const;
   inline isl::union_set bind(isl::id id) const;
+  inline isl::union_set bind(const std::string &id) const;
   inline isl::union_pw_aff coalesce() const;
-  inline isl_size dim(isl::dim type) const;
+  inline class size 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);
-  static inline isl::union_pw_aff empty_ctx(isl::ctx ctx);
-  static inline isl::union_pw_aff empty_space(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 stat foreach_pw_aff(const std::function<stat(pw_aff)> &fn) const;
-  inline isl::pw_aff_list get_pw_aff_list() const;
-  inline isl::space get_space() const;
+  inline isl::pw_multi_aff extract_pw_multi_aff(const isl::space &space) const;
+  inline isl::multi_union_pw_aff flat_range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::union_pw_multi_aff flat_range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline stat foreach_pw_aff(const std::function<stat(isl::pw_aff)> &fn) const;
   inline isl::union_pw_aff gist(isl::union_set context) const;
-  inline isl::union_pw_aff gist_params(isl::set context) const;
+  inline boolean has_range_tuple_id() const;
   inline isl::union_pw_aff intersect_domain(isl::space space) const;
   inline isl::union_pw_aff intersect_domain(isl::union_set uset) const;
   inline isl::union_pw_aff intersect_domain_wrapped_domain(isl::union_set uset) const;
   inline isl::union_pw_aff intersect_domain_wrapped_range(isl::union_set uset) const;
   inline isl::union_pw_aff intersect_params(isl::set set) const;
+  inline boolean involves_locals() const;
   inline boolean involves_nan() const;
-  inline isl::val max_val() const;
-  inline isl::val min_val() const;
-  inline isl::union_pw_aff mod_val(isl::val f) const;
-  inline isl_size 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 boolean plain_is_equal(const isl::union_pw_aff &upa2) const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::union_pw_aff_list list() const;
+  inline isl::multi_union_pw_aff neg() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) 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::pw_multi_aff_list pw_multi_aff_list() const;
+  inline isl::union_pw_multi_aff range_factor_domain() const;
+  inline isl::union_pw_multi_aff range_factor_range() const;
+  inline isl::multi_union_pw_aff range_product(const isl::multi_union_pw_aff &multi2) const;
+  inline isl::union_pw_multi_aff range_product(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::id range_tuple_id() const;
+  inline isl::multi_union_pw_aff reset_range_tuple_id() const;
+  inline isl::multi_union_pw_aff reset_tuple_id(isl::dim type) const;
+  inline isl::multi_union_pw_aff scale(const isl::multi_val &mv) const;
+  inline isl::multi_union_pw_aff scale(const isl::val &v) const;
+  inline isl::multi_union_pw_aff scale(long v) const;
+  inline isl::multi_union_pw_aff scale_down(const isl::multi_val &mv) const;
+  inline isl::multi_union_pw_aff scale_down(const isl::val &v) const;
+  inline isl::multi_union_pw_aff scale_down(long v) const;
+  inline isl::multi_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) const;
+  inline isl::multi_union_pw_aff set_range_tuple(const isl::id &id) const;
+  inline isl::multi_union_pw_aff set_range_tuple(const std::string &id) const;
+  inline isl::multi_union_pw_aff set_union_pw_aff(int pos, const isl::union_pw_aff &el) const;
+  inline class size size() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
+  inline isl::multi_union_pw_aff sub(const isl::multi_union_pw_aff &multi2) const;
   inline isl::union_pw_aff sub(isl::union_pw_aff upa2) const;
+  inline isl::union_pw_multi_aff sub(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::union_pw_aff sub(const isl::aff &upa2) const;
+  inline isl::union_pw_aff sub(const isl::pw_aff &upa2) const;
   inline isl::union_pw_aff subtract_domain(isl::space space) const;
   inline isl::union_pw_aff subtract_domain(isl::union_set uset) const;
+  inline isl::union_pw_aff_list to_list() const;
+  inline isl::multi_union_pw_aff union_add(const isl::multi_union_pw_aff &mupa2) const;
   inline isl::union_pw_aff union_add(isl::union_pw_aff upa2) const;
-  inline isl::union_set zero_union_set() const;
+  inline isl::union_pw_multi_aff union_add(const isl::union_pw_multi_aff &upma2) const;
+  inline isl::union_pw_aff union_add(const isl::aff &upa2) const;
+  inline isl::union_pw_aff union_add(const isl::pw_aff &upa2) const;
 };
 
 // declarations for isl::union_pw_aff_list
 inline union_pw_aff_list manage(__isl_take isl_union_pw_aff_list *ptr);
 inline union_pw_aff_list manage_copy(__isl_keep isl_union_pw_aff_list *ptr);
 
 class union_pw_aff_list {
   friend inline union_pw_aff_list manage(__isl_take isl_union_pw_aff_list *ptr);
   friend inline union_pw_aff_list manage_copy(__isl_keep isl_union_pw_aff_list *ptr);
 
+protected:
   isl_union_pw_aff_list *ptr = nullptr;
 
   inline explicit union_pw_aff_list(__isl_take isl_union_pw_aff_list *ptr);
 
 public:
   inline /* implicit */ union_pw_aff_list();
   inline /* implicit */ union_pw_aff_list(const union_pw_aff_list &obj);
+  inline explicit union_pw_aff_list(isl::ctx ctx, int n);
+  inline explicit union_pw_aff_list(isl::union_pw_aff el);
+  inline explicit union_pw_aff_list(isl::ctx ctx, const std::string &str);
   inline union_pw_aff_list &operator=(union_pw_aff_list obj);
   inline ~union_pw_aff_list();
   inline __isl_give isl_union_pw_aff_list *copy() const &;
   inline __isl_give isl_union_pw_aff_list *copy() && = delete;
   inline __isl_keep isl_union_pw_aff_list *get() const;
   inline __isl_give isl_union_pw_aff_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::union_pw_aff_list add(isl::union_pw_aff el) const;
-  static inline isl::union_pw_aff_list alloc(isl::ctx ctx, int n);
+  inline isl::union_pw_aff at(int index) const;
+  inline isl::union_pw_aff get_at(int index) const;
   inline isl::union_pw_aff_list clear() const;
   inline isl::union_pw_aff_list concat(isl::union_pw_aff_list list2) const;
   inline isl::union_pw_aff_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(union_pw_aff)> &fn) const;
-  static inline isl::union_pw_aff_list from_union_pw_aff(isl::union_pw_aff el);
-  inline isl::union_pw_aff get_at(int index) const;
-  inline isl::union_pw_aff get_union_pw_aff(int index) const;
+  inline stat foreach(const std::function<stat(isl::union_pw_aff)> &fn) const;
   inline isl::union_pw_aff_list insert(unsigned int pos, isl::union_pw_aff el) const;
-  inline isl_size n_union_pw_aff() const;
-  inline isl::union_pw_aff_list reverse() const;
-  inline isl::union_pw_aff_list set_union_pw_aff(int index, isl::union_pw_aff el) const;
-  inline isl_size size() const;
-  inline isl::union_pw_aff_list swap(unsigned int pos1, unsigned int pos2) const;
+  inline class size size() const;
 };
 
 // declarations for isl::union_pw_multi_aff
 inline union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr);
 inline union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr);
 
 class union_pw_multi_aff {
   friend inline union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr);
   friend inline union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr);
 
+protected:
   isl_union_pw_multi_aff *ptr = nullptr;
 
   inline explicit union_pw_multi_aff(__isl_take isl_union_pw_multi_aff *ptr);
 
 public:
   inline /* implicit */ union_pw_multi_aff();
   inline /* implicit */ union_pw_multi_aff(const union_pw_multi_aff &obj);
-  inline /* implicit */ union_pw_multi_aff(isl::aff aff);
   inline explicit union_pw_multi_aff(isl::union_set uset);
   inline /* implicit */ union_pw_multi_aff(isl::multi_aff ma);
-  inline explicit union_pw_multi_aff(isl::multi_union_pw_aff mupa);
   inline /* implicit */ union_pw_multi_aff(isl::pw_multi_aff pma);
   inline explicit union_pw_multi_aff(isl::union_map umap);
   inline /* implicit */ union_pw_multi_aff(isl::union_pw_aff upa);
   inline explicit union_pw_multi_aff(isl::ctx ctx, const std::string &str);
   inline union_pw_multi_aff &operator=(union_pw_multi_aff obj);
   inline ~union_pw_multi_aff();
   inline __isl_give isl_union_pw_multi_aff *copy() const &;
   inline __isl_give isl_union_pw_multi_aff *copy() && = delete;
   inline __isl_keep isl_union_pw_multi_aff *get() const;
   inline __isl_give isl_union_pw_multi_aff *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::union_pw_multi_aff add(isl::union_pw_multi_aff upma2) const;
   inline isl::union_pw_multi_aff add_pw_multi_aff(isl::pw_multi_aff pma) const;
-  inline isl::union_pw_multi_aff align_params(isl::space model) const;
   inline isl::union_pw_multi_aff apply(isl::union_pw_multi_aff upma2) const;
+  inline isl::multi_union_pw_aff as_multi_union_pw_aff() const;
   inline isl::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::union_map as_union_map() const;
   inline isl::union_pw_multi_aff coalesce() const;
-  inline isl_size 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);
   static inline isl::union_pw_multi_aff empty(isl::ctx ctx);
-  static inline isl::union_pw_multi_aff empty_space(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 stat foreach_pw_multi_aff(const std::function<stat(pw_multi_aff)> &fn) const;
-  static inline isl::union_pw_multi_aff from_union_set(isl::union_set uset);
-  inline isl::pw_multi_aff_list get_pw_multi_aff_list() const;
-  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::space space) const;
   inline isl::union_pw_multi_aff intersect_domain(isl::union_set uset) const;
   inline isl::union_pw_multi_aff intersect_domain_wrapped_domain(isl::union_set uset) const;
   inline isl::union_pw_multi_aff intersect_domain_wrapped_range(isl::union_set uset) const;
   inline isl::union_pw_multi_aff intersect_params(isl::set set) const;
   inline boolean involves_locals() const;
-  inline boolean involves_nan() const;
   inline boolean isa_pw_multi_aff() const;
-  static inline isl::union_pw_multi_aff multi_val_on_domain(isl::union_set domain, isl::multi_val mv);
-  inline isl_size n_pw_multi_aff() const;
-  inline isl::union_pw_multi_aff neg() const;
   inline boolean plain_is_empty() const;
-  inline boolean plain_is_equal(const isl::union_pw_multi_aff &upma2) const;
   inline isl::union_pw_multi_aff preimage_domain_wrapped_domain(isl::union_pw_multi_aff upma2) const;
   inline isl::union_pw_multi_aff pullback(isl::union_pw_multi_aff upma2) const;
+  inline isl::pw_multi_aff_list pw_multi_aff_list() const;
+  inline isl::pw_multi_aff_list get_pw_multi_aff_list() const;
   inline isl::union_pw_multi_aff range_factor_domain() const;
   inline isl::union_pw_multi_aff range_factor_range() const;
   inline isl::union_pw_multi_aff range_product(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::space space() const;
+  inline isl::space get_space() const;
   inline isl::union_pw_multi_aff sub(isl::union_pw_multi_aff upma2) const;
   inline isl::union_pw_multi_aff subtract_domain(isl::space space) 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;
 };
 
-// declarations for isl::union_pw_multi_aff_list
-inline union_pw_multi_aff_list manage(__isl_take isl_union_pw_multi_aff_list *ptr);
-inline union_pw_multi_aff_list manage_copy(__isl_keep isl_union_pw_multi_aff_list *ptr);
-
-class union_pw_multi_aff_list {
-  friend inline union_pw_multi_aff_list manage(__isl_take isl_union_pw_multi_aff_list *ptr);
-  friend inline union_pw_multi_aff_list manage_copy(__isl_keep isl_union_pw_multi_aff_list *ptr);
-
-  isl_union_pw_multi_aff_list *ptr = nullptr;
-
-  inline explicit union_pw_multi_aff_list(__isl_take isl_union_pw_multi_aff_list *ptr);
-
-public:
-  inline /* implicit */ union_pw_multi_aff_list();
-  inline /* implicit */ union_pw_multi_aff_list(const union_pw_multi_aff_list &obj);
-  inline union_pw_multi_aff_list &operator=(union_pw_multi_aff_list obj);
-  inline ~union_pw_multi_aff_list();
-  inline __isl_give isl_union_pw_multi_aff_list *copy() const &;
-  inline __isl_give isl_union_pw_multi_aff_list *copy() && = delete;
-  inline __isl_keep isl_union_pw_multi_aff_list *get() const;
-  inline __isl_give isl_union_pw_multi_aff_list *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::union_pw_multi_aff_list add(isl::union_pw_multi_aff el) const;
-  static inline isl::union_pw_multi_aff_list alloc(isl::ctx ctx, int n);
-  inline isl::union_pw_multi_aff_list clear() const;
-  inline isl::union_pw_multi_aff_list concat(isl::union_pw_multi_aff_list list2) const;
-  inline isl::union_pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(union_pw_multi_aff)> &fn) const;
-  static inline isl::union_pw_multi_aff_list from_union_pw_multi_aff(isl::union_pw_multi_aff el);
-  inline isl::union_pw_multi_aff get_at(int index) const;
-  inline isl::union_pw_multi_aff get_union_pw_multi_aff(int index) const;
-  inline isl::union_pw_multi_aff_list insert(unsigned int pos, isl::union_pw_multi_aff el) const;
-  inline isl_size n_union_pw_multi_aff() const;
-  inline isl::union_pw_multi_aff_list reverse() const;
-  inline isl::union_pw_multi_aff_list set_union_pw_multi_aff(int index, isl::union_pw_multi_aff el) const;
-  inline isl_size size() const;
-  inline isl::union_pw_multi_aff_list swap(unsigned int pos1, unsigned int pos2) const;
-};
-
-// declarations for isl::union_pw_qpolynomial
-inline union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr);
-inline union_pw_qpolynomial manage_copy(__isl_keep isl_union_pw_qpolynomial *ptr);
-
-class union_pw_qpolynomial {
-  friend inline union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr);
-  friend inline union_pw_qpolynomial manage_copy(__isl_keep isl_union_pw_qpolynomial *ptr);
-
-  isl_union_pw_qpolynomial *ptr = nullptr;
-
-  inline explicit union_pw_qpolynomial(__isl_take isl_union_pw_qpolynomial *ptr);
-
-public:
-  inline /* implicit */ union_pw_qpolynomial();
-  inline /* implicit */ union_pw_qpolynomial(const union_pw_qpolynomial &obj);
-  inline explicit union_pw_qpolynomial(isl::ctx ctx, const std::string &str);
-  inline union_pw_qpolynomial &operator=(union_pw_qpolynomial obj);
-  inline ~union_pw_qpolynomial();
-  inline __isl_give isl_union_pw_qpolynomial *copy() const &;
-  inline __isl_give isl_union_pw_qpolynomial *copy() && = delete;
-  inline __isl_keep isl_union_pw_qpolynomial *get() const;
-  inline __isl_give isl_union_pw_qpolynomial *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-
-  inline isl::union_pw_qpolynomial add(isl::union_pw_qpolynomial upwqp2) const;
-  inline isl::union_pw_qpolynomial add_pw_qpolynomial(isl::pw_qpolynomial pwqp) const;
-  inline isl::union_pw_qpolynomial align_params(isl::space model) const;
-  inline isl::union_pw_qpolynomial coalesce() const;
-  inline isl_size 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 space) const;
-  inline int find_dim_by_name(isl::dim type, const std::string &name) const;
-  inline stat foreach_pw_qpolynomial(const std::function<stat(pw_qpolynomial)> &fn) const;
-  static inline isl::union_pw_qpolynomial from_pw_qpolynomial(isl::pw_qpolynomial pwqp);
-  inline isl::pw_qpolynomial_list get_pw_qpolynomial_list() const;
-  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_domain_space(isl::space space) const;
-  inline isl::union_pw_qpolynomial intersect_domain_union_set(isl::union_set uset) const;
-  inline isl::union_pw_qpolynomial intersect_domain_wrapped_domain(isl::union_set uset) const;
-  inline isl::union_pw_qpolynomial intersect_domain_wrapped_range(isl::union_set uset) const;
-  inline isl::union_pw_qpolynomial intersect_params(isl::set set) const;
-  inline boolean involves_nan() const;
-  inline isl::union_pw_qpolynomial mul(isl::union_pw_qpolynomial upwqp2) const;
-  inline isl_size n_pw_qpolynomial() const;
-  inline isl::union_pw_qpolynomial neg() const;
-  inline boolean plain_is_equal(const isl::union_pw_qpolynomial &upwqp2) 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 subtract_domain_space(isl::space space) const;
-  inline isl::union_pw_qpolynomial subtract_domain_union_set(isl::union_set uset) const;
-  inline isl::union_pw_qpolynomial to_polynomial(int sign) const;
-  static inline isl::union_pw_qpolynomial zero(isl::space space);
-  static inline isl::union_pw_qpolynomial zero_ctx(isl::ctx ctx);
-  static inline isl::union_pw_qpolynomial zero_space(isl::space space);
-};
-
 // declarations for isl::union_set
 inline union_set manage(__isl_take isl_union_set *ptr);
 inline union_set manage_copy(__isl_keep isl_union_set *ptr);
 
 class union_set {
   friend inline union_set manage(__isl_take isl_union_set *ptr);
   friend inline union_set manage_copy(__isl_keep isl_union_set *ptr);
 
+protected:
   isl_union_set *ptr = nullptr;
 
   inline explicit union_set(__isl_take isl_union_set *ptr);
 
 public:
   inline /* implicit */ union_set();
   inline /* implicit */ union_set(const union_set &obj);
   inline /* implicit */ union_set(isl::basic_set bset);
   inline /* implicit */ union_set(isl::point pnt);
   inline /* implicit */ union_set(isl::set set);
   inline explicit union_set(isl::ctx ctx, const std::string &str);
   inline union_set &operator=(union_set obj);
   inline ~union_set();
   inline __isl_give isl_union_set *copy() const &;
   inline __isl_give isl_union_set *copy() && = delete;
   inline __isl_keep isl_union_set *get() const;
   inline __isl_give isl_union_set *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() 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::set as_set() 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::union_set compute_divs() const;
   inline boolean contains(const isl::space &space) const;
   inline isl::union_set detect_equalities() const;
-  inline isl_size dim(isl::dim type) const;
   static inline isl::union_set empty(isl::ctx ctx);
+  inline boolean every_set(const std::function<boolean(isl::set)> &test) const;
   inline isl::set extract_set(isl::space space) const;
-  inline stat foreach_point(const std::function<stat(point)> &fn) const;
-  inline stat foreach_set(const std::function<stat(set)> &fn) const;
-  inline isl::basic_set_list get_basic_set_list() const;
-  inline uint32_t get_hash() const;
-  inline isl::set_list get_set_list() const;
-  inline isl::space get_space() const;
+  inline stat foreach_point(const std::function<stat(isl::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::set)> &fn) 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 boolean is_disjoint(const isl::union_set &uset2) const;
   inline boolean is_empty() const;
   inline boolean is_equal(const isl::union_set &uset2) const;
-  inline boolean is_params() const;
   inline boolean is_strict_subset(const isl::union_set &uset2) const;
   inline boolean is_subset(const isl::union_set &uset2) const;
   inline boolean isa_set() 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 isl_size n_set() const;
   inline isl::set params() const;
   inline isl::union_set polyhedral_hull() const;
   inline isl::union_set preimage(isl::multi_aff ma) const;
   inline isl::union_set preimage(isl::pw_multi_aff pma) const;
   inline isl::union_set preimage(isl::union_pw_multi_aff upma) const;
-  inline isl::union_set product(isl::union_set uset2) const;
-  inline isl::union_set project_out(isl::dim type, unsigned int first, unsigned int n) const;
-  inline isl::union_set project_out_all_params() const;
-  inline isl::union_set remove_divs() const;
-  inline isl::union_set remove_redundancies() const;
-  inline isl::union_set reset_user() const;
-  inline isl::basic_set sample() const;
   inline isl::point sample_point() const;
-  inline isl::union_set simple_hull() const;
-  inline isl::union_set solutions() const;
+  inline isl::set_list set_list() const;
+  inline isl::set_list get_set_list() const;
+  inline isl::space space() const;
+  inline isl::space get_space() const;
   inline isl::union_set subtract(isl::union_set uset2) const;
+  inline isl::union_set_list to_list() const;
   inline isl::union_set unite(isl::union_set uset2) const;
   inline isl::union_set universe() const;
   inline isl::union_map unwrap() const;
-  inline isl::union_map wrapped_domain_map() const;
 };
 
 // declarations for isl::union_set_list
 inline union_set_list manage(__isl_take isl_union_set_list *ptr);
 inline union_set_list manage_copy(__isl_keep isl_union_set_list *ptr);
 
 class union_set_list {
   friend inline union_set_list manage(__isl_take isl_union_set_list *ptr);
   friend inline union_set_list manage_copy(__isl_keep isl_union_set_list *ptr);
 
+protected:
   isl_union_set_list *ptr = nullptr;
 
   inline explicit union_set_list(__isl_take isl_union_set_list *ptr);
 
 public:
   inline /* implicit */ union_set_list();
   inline /* implicit */ union_set_list(const union_set_list &obj);
+  inline explicit union_set_list(isl::ctx ctx, int n);
+  inline explicit union_set_list(isl::union_set el);
+  inline explicit union_set_list(isl::ctx ctx, const std::string &str);
   inline union_set_list &operator=(union_set_list obj);
   inline ~union_set_list();
   inline __isl_give isl_union_set_list *copy() const &;
   inline __isl_give isl_union_set_list *copy() && = delete;
   inline __isl_keep isl_union_set_list *get() const;
   inline __isl_give isl_union_set_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::union_set_list add(isl::union_set el) const;
-  static inline isl::union_set_list alloc(isl::ctx ctx, int n);
+  inline isl::union_set at(int index) const;
+  inline isl::union_set get_at(int index) const;
   inline isl::union_set_list clear() const;
   inline isl::union_set_list concat(isl::union_set_list list2) const;
   inline isl::union_set_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(union_set)> &fn) const;
-  static inline isl::union_set_list from_union_set(isl::union_set el);
-  inline isl::union_set get_at(int index) const;
-  inline isl::union_set get_union_set(int index) const;
+  inline stat foreach(const std::function<stat(isl::union_set)> &fn) const;
   inline isl::union_set_list insert(unsigned int pos, isl::union_set el) const;
-  inline isl_size n_union_set() const;
-  inline isl::union_set_list reverse() const;
-  inline isl::union_set_list set_union_set(int index, isl::union_set el) const;
-  inline isl_size size() const;
-  inline isl::union_set_list swap(unsigned int pos1, unsigned int pos2) const;
-  inline isl::union_set unite() const;
+  inline class size size() const;
 };
 
 // declarations for isl::val
 inline val manage(__isl_take isl_val *ptr);
 inline val manage_copy(__isl_keep isl_val *ptr);
 
 class val {
   friend inline val manage(__isl_take isl_val *ptr);
   friend inline val manage_copy(__isl_keep isl_val *ptr);
 
+protected:
   isl_val *ptr = nullptr;
 
   inline explicit val(__isl_take isl_val *ptr);
 
 public:
   inline /* implicit */ val();
   inline /* implicit */ val(const val &obj);
   inline explicit val(isl::ctx ctx, long i);
   inline explicit val(isl::ctx ctx, const std::string &str);
   inline val &operator=(val obj);
   inline ~val();
   inline __isl_give isl_val *copy() const &;
   inline __isl_give isl_val *copy() && = delete;
   inline __isl_keep isl_val *get() const;
   inline __isl_give isl_val *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::val abs() const;
   inline boolean abs_eq(const isl::val &v2) const;
+  inline boolean abs_eq(long v2) const;
   inline isl::val add(isl::val v2) const;
-  inline isl::val add_ui(unsigned long v2) const;
+  inline isl::val add(long v2) const;
   inline isl::val ceil() const;
   inline int cmp_si(long i) const;
+  inline long den_si() const;
+  inline long get_den_si() const;
   inline isl::val div(isl::val v2) const;
-  inline isl::val div_ui(unsigned long v2) const;
+  inline isl::val div(long v2) const;
   inline boolean eq(const isl::val &v2) const;
-  inline boolean eq_si(long i) const;
+  inline boolean eq(long v2) const;
   inline isl::val floor() const;
   inline isl::val gcd(isl::val v2) const;
+  inline isl::val gcd(long v2) const;
   inline boolean ge(const isl::val &v2) const;
-  inline uint32_t get_hash() const;
-  inline long get_num_si() const;
+  inline boolean ge(long v2) const;
   inline boolean gt(const isl::val &v2) const;
-  inline boolean gt_si(long i) const;
+  inline boolean gt(long v2) 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 boolean is_divisible_by(const isl::val &v2) const;
+  inline boolean is_divisible_by(long v2) const;
   inline boolean is_infty() const;
   inline boolean is_int() const;
   inline boolean is_nan() const;
   inline boolean is_neg() const;
   inline boolean is_neginfty() const;
   inline boolean is_negone() const;
   inline boolean is_nonneg() const;
   inline boolean is_nonpos() const;
   inline boolean is_one() const;
   inline boolean is_pos() const;
   inline boolean is_rat() const;
   inline boolean is_zero() const;
   inline boolean le(const isl::val &v2) const;
+  inline boolean le(long v2) const;
   inline boolean lt(const isl::val &v2) const;
+  inline boolean lt(long v2) const;
   inline isl::val max(isl::val v2) const;
+  inline isl::val max(long v2) const;
   inline isl::val min(isl::val v2) const;
+  inline isl::val min(long v2) const;
   inline isl::val mod(isl::val v2) const;
+  inline isl::val mod(long v2) const;
   inline isl::val mul(isl::val v2) const;
-  inline isl::val mul_ui(unsigned long v2) const;
-  inline isl_size n_abs_num_chunks(size_t size) const;
+  inline isl::val mul(long v2) const;
   static inline isl::val nan(isl::ctx ctx);
   inline boolean ne(const isl::val &v2) const;
+  inline boolean ne(long v2) const;
   inline isl::val neg() const;
   static inline isl::val neginfty(isl::ctx ctx);
   static inline isl::val negone(isl::ctx ctx);
+  inline long num_si() const;
+  inline long get_num_si() const;
   static inline isl::val one(isl::ctx ctx);
   inline isl::val pow2() const;
-  inline isl::val set_si(long i) const;
   inline int sgn() const;
   inline isl::val sub(isl::val v2) const;
+  inline isl::val sub(long v2) const;
   inline isl::val sub_ui(unsigned long v2) const;
+  inline isl::val_list to_list() const;
   inline isl::val trunc() const;
   static inline isl::val zero(isl::ctx ctx);
 };
 
 // declarations for isl::val_list
 inline val_list manage(__isl_take isl_val_list *ptr);
 inline val_list manage_copy(__isl_keep isl_val_list *ptr);
 
 class val_list {
   friend inline val_list manage(__isl_take isl_val_list *ptr);
   friend inline val_list manage_copy(__isl_keep isl_val_list *ptr);
 
+protected:
   isl_val_list *ptr = nullptr;
 
   inline explicit val_list(__isl_take isl_val_list *ptr);
 
 public:
   inline /* implicit */ val_list();
   inline /* implicit */ val_list(const val_list &obj);
+  inline explicit val_list(isl::ctx ctx, int n);
+  inline explicit val_list(isl::val el);
+  inline explicit val_list(isl::ctx ctx, const std::string &str);
   inline val_list &operator=(val_list obj);
   inline ~val_list();
   inline __isl_give isl_val_list *copy() const &;
   inline __isl_give isl_val_list *copy() && = delete;
   inline __isl_keep isl_val_list *get() const;
   inline __isl_give isl_val_list *release();
   inline bool is_null() const;
   inline isl::ctx ctx() const;
-  inline void dump() const;
 
   inline isl::val_list add(isl::val el) const;
-  static inline isl::val_list alloc(isl::ctx ctx, int n);
+  inline isl::val_list add(long el) const;
+  inline isl::val at(int index) const;
+  inline isl::val get_at(int index) const;
   inline isl::val_list clear() const;
   inline isl::val_list concat(isl::val_list list2) const;
   inline isl::val_list drop(unsigned int first, unsigned int n) const;
-  inline stat foreach(const std::function<stat(val)> &fn) const;
-  static inline isl::val_list from_val(isl::val el);
-  inline isl::val get_at(int index) const;
-  inline isl::val get_val(int index) const;
+  inline stat foreach(const std::function<stat(isl::val)> &fn) const;
   inline isl::val_list insert(unsigned int pos, isl::val el) const;
-  inline isl_size n_val() const;
-  inline isl::val_list reverse() const;
-  inline isl::val_list set_val(int index, isl::val el) const;
-  inline isl_size size() const;
-  inline isl::val_list swap(unsigned int pos1, unsigned int pos2) const;
-};
-
-// declarations for isl::vec
-inline vec manage(__isl_take isl_vec *ptr);
-inline vec manage_copy(__isl_keep isl_vec *ptr);
-
-class vec {
-  friend inline vec manage(__isl_take isl_vec *ptr);
-  friend inline vec manage_copy(__isl_keep isl_vec *ptr);
-
-  isl_vec *ptr = nullptr;
-
-  inline explicit vec(__isl_take isl_vec *ptr);
-
-public:
-  inline /* implicit */ vec();
-  inline /* implicit */ vec(const vec &obj);
-  inline vec &operator=(vec obj);
-  inline ~vec();
-  inline __isl_give isl_vec *copy() const &;
-  inline __isl_give isl_vec *copy() && = delete;
-  inline __isl_keep isl_vec *get() const;
-  inline __isl_give isl_vec *release();
-  inline bool is_null() const;
-  inline isl::ctx ctx() const;
-  inline void dump() const;
-
-  inline isl::vec add(isl::vec vec2) const;
-  inline isl::vec add_els(unsigned int n) const;
-  static inline isl::vec alloc(isl::ctx ctx, unsigned int size);
-  inline isl::vec ceil() const;
-  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 boolean is_equal(const isl::vec &vec2) 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 isl_size size() const;
-  inline isl::vec sort() const;
-  static inline isl::vec zero(isl::ctx ctx, unsigned int size);
-  inline isl::vec zero_extend(unsigned int size) const;
+  inline isl::val_list insert(unsigned int pos, long el) const;
+  inline class size size() const;
 };
 
 // implementations for isl::aff
 aff manage(__isl_take isl_aff *ptr) {
   return aff(ptr);
 }
 aff manage_copy(__isl_keep isl_aff *ptr) {
   ptr = isl_aff_copy(ptr);
   return aff(ptr);
 }
 
 aff::aff()
     : ptr(nullptr) {}
 
 aff::aff(const aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 aff::aff(__isl_take isl_aff *ptr)
     : ptr(ptr) {}
 
 aff::aff(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_aff_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
+
 aff::aff(isl::local_space ls, isl::val val)
 {
   auto res = isl_aff_val_on_domain(ls.release(), val.release());
   ptr = res;
 }
+
 aff::aff(isl::local_space ls)
 {
   auto res = isl_aff_zero_on_domain(ls.release());
   ptr = res;
 }
 
 aff &aff::operator=(aff obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_aff *aff::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool aff::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx aff::ctx() const {
   return isl::ctx(isl_aff_get_ctx(ptr));
 }
 
-void aff::dump() const {
-  isl_aff_dump(get());
-}
-
-
 isl::aff aff::add(isl::aff aff2) const
 {
   auto res = isl_aff_add(copy(), aff2.release());
   return manage(res);
 }
 
-isl::aff aff::add_coefficient_si(isl::dim type, int pos, int v) const
+isl::multi_aff aff::add(const isl::multi_aff &multi2) const
 {
-  auto res = isl_aff_add_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
-  return manage(res);
+  return isl::multi_aff(*this).add(multi2);
 }
 
-isl::aff aff::add_coefficient_val(isl::dim type, int pos, isl::val v) const
+isl::multi_pw_aff aff::add(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_aff_add_coefficient_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
-  return manage(res);
+  return isl::pw_aff(*this).add(multi2);
+}
+
+isl::multi_union_pw_aff aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).add(multi2);
+}
+
+isl::pw_aff aff::add(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).add(pwaff2);
+}
+
+isl::pw_multi_aff aff::add(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_aff(*this).add(pma2);
+}
+
+isl::union_pw_aff aff::add(const isl::union_pw_aff &upa2) const
+{
+  return isl::pw_aff(*this).add(upa2);
+}
+
+isl::union_pw_multi_aff aff::add(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).add(upma2);
 }
 
 isl::aff aff::add_constant(isl::val v) const
 {
   auto res = isl_aff_add_constant_val(copy(), v.release());
   return manage(res);
 }
 
-isl::aff aff::add_constant_num_si(int v) const
+isl::aff aff::add_constant(long v) const
 {
-  auto res = isl_aff_add_constant_num_si(copy(), v);
-  return manage(res);
+  return this->add_constant(isl::val(ctx(), v));
+}
+
+isl::multi_aff aff::add_constant(const isl::multi_val &mv) const
+{
+  return isl::multi_aff(*this).add_constant(mv);
 }
 
 isl::aff aff::add_constant_si(int v) const
 {
   auto res = isl_aff_add_constant_si(copy(), v);
   return manage(res);
 }
 
-isl::aff aff::add_dims(isl::dim type, unsigned int n) const
+isl::pw_aff aff::add_dims(isl::dim type, unsigned int n) const
 {
-  auto res = isl_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return isl::pw_aff(*this).add_dims(type, n);
 }
 
-isl::aff aff::align_params(isl::space model) const
+isl::union_pw_multi_aff aff::add_pw_multi_aff(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_aff_align_params(copy(), model.release());
-  return manage(res);
+  return isl::pw_aff(*this).add_pw_multi_aff(pma);
+}
+
+isl::union_pw_multi_aff aff::apply(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).apply(upma2);
+}
+
+isl::aff aff::as_aff() const
+{
+  return isl::pw_aff(*this).as_aff();
+}
+
+isl::map aff::as_map() const
+{
+  return isl::pw_aff(*this).as_map();
+}
+
+isl::multi_aff aff::as_multi_aff() const
+{
+  return isl::pw_aff(*this).as_multi_aff();
+}
+
+isl::multi_union_pw_aff aff::as_multi_union_pw_aff() const
+{
+  return isl::pw_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff aff::as_pw_multi_aff() const
+{
+  return isl::pw_aff(*this).as_pw_multi_aff();
+}
+
+isl::set aff::as_set() const
+{
+  return isl::multi_aff(*this).as_set();
+}
+
+isl::union_map aff::as_union_map() const
+{
+  return isl::pw_aff(*this).as_union_map();
+}
+
+isl::aff aff::at(int pos) const
+{
+  return isl::multi_aff(*this).at(pos);
 }
 
 isl::basic_set aff::bind(isl::id id) const
 {
   auto res = isl_aff_bind_id(copy(), id.release());
   return manage(res);
 }
 
+isl::basic_set aff::bind(const std::string &id) const
+{
+  return this->bind(isl::id(ctx(), id));
+}
+
+isl::basic_set aff::bind(const isl::multi_id &tuple) const
+{
+  return isl::multi_aff(*this).bind(tuple);
+}
+
+isl::pw_aff aff::bind_domain(const isl::multi_id &tuple) const
+{
+  return isl::pw_aff(*this).bind_domain(tuple);
+}
+
+isl::pw_aff aff::bind_domain_wrapped_domain(const isl::multi_id &tuple) const
+{
+  return isl::pw_aff(*this).bind_domain_wrapped_domain(tuple);
+}
+
 isl::aff aff::ceil() const
 {
   auto res = isl_aff_ceil(copy());
   return manage(res);
 }
 
-int aff::coefficient_sgn(isl::dim type, int pos) const
+isl::pw_aff aff::coalesce() const
 {
-  auto res = isl_aff_coefficient_sgn(get(), static_cast<enum isl_dim_type>(type), pos);
-  return res;
+  return isl::pw_aff(*this).coalesce();
 }
 
-isl_size aff::dim(isl::dim type) const
+isl::pw_aff aff::cond(const isl::pw_aff &pwaff_true, const isl::pw_aff &pwaff_false) const
 {
-  auto res = isl_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::pw_aff(*this).cond(pwaff_true, pwaff_false);
 }
 
-isl::aff aff::div(isl::aff aff2) const
+isl::multi_val aff::constant_multi_val() const
 {
-  auto res = isl_aff_div(copy(), aff2.release());
+  return isl::multi_aff(*this).constant_multi_val();
+}
+
+isl::val aff::constant_val() const
+{
+  auto res = isl_aff_get_constant_val(get());
   return manage(res);
 }
 
-isl::aff aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::val aff::get_constant_val() const
+{
+  return constant_val();
+}
+
+isl::val aff::denominator_val() const
 {
-  auto res = isl_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_aff_get_denominator_val(get());
   return manage(res);
 }
 
-isl::basic_set aff::eq_basic_set(isl::aff aff2) const
+isl::val aff::get_denominator_val() const
+{
+  return denominator_val();
+}
+
+class size aff::dim(isl::dim type) const
+{
+  return isl::multi_aff(*this).dim(type);
+}
+
+isl::id aff::dim_id(isl::dim type, unsigned int pos) const
+{
+  return isl::pw_aff(*this).dim_id(type, pos);
+}
+
+isl::aff aff::div(isl::aff aff2) const
 {
-  auto res = isl_aff_eq_basic_set(copy(), aff2.release());
+  auto res = isl_aff_div(copy(), aff2.release());
   return manage(res);
 }
 
+isl::pw_aff aff::div(const isl::pw_aff &pa2) const
+{
+  return isl::pw_aff(*this).div(pa2);
+}
+
+isl::set aff::domain() const
+{
+  return isl::pw_aff(*this).domain();
+}
+
+isl::space aff::domain_space() const
+{
+  return isl::pw_aff(*this).domain_space();
+}
+
+isl::pw_multi_aff aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+{
+  return isl::pw_aff(*this).drop_dims(type, first, n);
+}
+
 isl::set aff::eq_set(isl::aff aff2) const
 {
   auto res = isl_aff_eq_set(copy(), aff2.release());
   return manage(res);
 }
 
+isl::set aff::eq_set(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).eq_set(pwaff2);
+}
+
 isl::val aff::eval(isl::point pnt) const
 {
   auto res = isl_aff_eval(copy(), pnt.release());
   return manage(res);
 }
 
-int aff::find_dim_by_name(isl::dim type, const std::string &name) const
+isl::pw_multi_aff aff::extract_pw_multi_aff(const isl::space &space) const
 {
-  auto res = isl_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return isl::pw_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::multi_aff aff::flat_range_product(const isl::multi_aff &multi2) const
+{
+  return isl::multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_pw_aff aff::flat_range_product(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_union_pw_aff aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::pw_multi_aff aff::flat_range_product(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_aff(*this).flat_range_product(pma2);
+}
+
+isl::union_pw_multi_aff aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).flat_range_product(upma2);
 }
 
 isl::aff aff::floor() const
 {
   auto res = isl_aff_floor(copy());
   return manage(res);
 }
 
-isl::aff aff::from_range() const
+stat aff::foreach_piece(const std::function<stat(isl::set, isl::aff)> &fn) const
 {
-  auto res = isl_aff_from_range(copy());
-  return manage(res);
+  return isl::pw_aff(*this).foreach_piece(fn);
 }
 
-isl::basic_set aff::ge_basic_set(isl::aff aff2) const
+stat aff::foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const
 {
-  auto res = isl_aff_ge_basic_set(copy(), aff2.release());
-  return manage(res);
+  return isl::pw_aff(*this).foreach_piece(fn);
+}
+
+stat aff::foreach_pw_aff(const std::function<stat(isl::pw_aff)> &fn) const
+{
+  return isl::pw_aff(*this).foreach_pw_aff(fn);
 }
 
 isl::set aff::ge_set(isl::aff aff2) const
 {
   auto res = isl_aff_ge_set(copy(), aff2.release());
   return manage(res);
 }
 
-isl::val aff::get_coefficient_val(isl::dim type, int pos) const
+isl::set aff::ge_set(const isl::pw_aff &pwaff2) const
 {
-  auto res = isl_aff_get_coefficient_val(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::pw_aff(*this).ge_set(pwaff2);
 }
 
-isl::val aff::get_constant_val() const
+isl::aff aff::gist(isl::set context) const
 {
-  auto res = isl_aff_get_constant_val(get());
+  auto res = isl_aff_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::val aff::get_denominator_val() const
+isl::union_pw_aff aff::gist(const isl::union_set &context) const
 {
-  auto res = isl_aff_get_denominator_val(get());
-  return manage(res);
+  return isl::pw_aff(*this).gist(context);
 }
 
-std::string aff::get_dim_name(isl::dim type, unsigned int pos) const
+isl::aff aff::gist(const isl::basic_set &context) const
 {
-  auto res = isl_aff_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return this->gist(isl::set(context));
 }
 
-isl::aff aff::get_div(int pos) const
+isl::aff aff::gist(const isl::point &context) const
 {
-  auto res = isl_aff_get_div(get(), pos);
-  return manage(res);
+  return this->gist(isl::set(context));
 }
 
-isl::local_space aff::get_domain_local_space() const
+isl::set aff::gt_set(isl::aff aff2) const
 {
-  auto res = isl_aff_get_domain_local_space(get());
+  auto res = isl_aff_gt_set(copy(), aff2.release());
   return manage(res);
 }
 
-isl::space aff::get_domain_space() const
+isl::set aff::gt_set(const isl::pw_aff &pwaff2) const
 {
-  auto res = isl_aff_get_domain_space(get());
-  return manage(res);
+  return isl::pw_aff(*this).gt_set(pwaff2);
 }
 
-uint32_t aff::get_hash() const
+boolean aff::has_range_tuple_id() const
 {
-  auto res = isl_aff_get_hash(get());
-  return res;
+  return isl::multi_aff(*this).has_range_tuple_id();
 }
 
-isl::local_space aff::get_local_space() const
+isl::multi_aff aff::identity() const
 {
-  auto res = isl_aff_get_local_space(get());
-  return manage(res);
+  return isl::multi_aff(*this).identity();
 }
 
-isl::space aff::get_space() const
+isl::pw_aff aff::insert_domain(const isl::space &domain) const
 {
-  auto res = isl_aff_get_space(get());
-  return manage(res);
+  return isl::pw_aff(*this).insert_domain(domain);
 }
 
-isl::aff aff::gist(isl::set context) const
+isl::pw_aff aff::intersect_domain(const isl::set &set) const
 {
-  auto res = isl_aff_gist(copy(), context.release());
-  return manage(res);
+  return isl::pw_aff(*this).intersect_domain(set);
 }
 
-isl::aff aff::gist_params(isl::set context) const
+isl::union_pw_aff aff::intersect_domain(const isl::space &space) const
 {
-  auto res = isl_aff_gist_params(copy(), context.release());
-  return manage(res);
+  return isl::pw_aff(*this).intersect_domain(space);
 }
 
-isl::basic_set aff::gt_basic_set(isl::aff aff2) const
+isl::union_pw_aff aff::intersect_domain(const isl::union_set &uset) const
 {
-  auto res = isl_aff_gt_basic_set(copy(), aff2.release());
-  return manage(res);
+  return isl::pw_aff(*this).intersect_domain(uset);
 }
 
-isl::set aff::gt_set(isl::aff aff2) const
+isl::union_pw_aff aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
 {
-  auto res = isl_aff_gt_set(copy(), aff2.release());
-  return manage(res);
+  return isl::pw_aff(*this).intersect_domain_wrapped_domain(uset);
 }
 
-isl::aff aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_pw_aff aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
 {
-  auto res = isl_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::pw_aff(*this).intersect_domain_wrapped_range(uset);
 }
 
-boolean aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::pw_aff aff::intersect_params(const isl::set &set) const
 {
-  auto res = isl_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::pw_aff(*this).intersect_params(set);
 }
 
 boolean aff::involves_locals() const
 {
-  auto res = isl_aff_involves_locals(get());
-  return manage(res);
+  return isl::multi_aff(*this).involves_locals();
+}
+
+boolean aff::involves_nan() const
+{
+  return isl::multi_aff(*this).involves_nan();
+}
+
+boolean aff::involves_param(const isl::id &id) const
+{
+  return isl::pw_aff(*this).involves_param(id);
+}
+
+boolean aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::id(ctx(), id));
+}
+
+boolean aff::involves_param(const isl::id_list &list) const
+{
+  return isl::pw_aff(*this).involves_param(list);
 }
 
 boolean aff::is_cst() const
 {
   auto res = isl_aff_is_cst(get());
   return manage(res);
 }
 
-boolean aff::is_nan() const
+boolean aff::is_equal(const isl::pw_aff &pa2) const
 {
-  auto res = isl_aff_is_nan(get());
-  return manage(res);
+  return isl::pw_aff(*this).is_equal(pa2);
 }
 
-isl::basic_set aff::le_basic_set(isl::aff aff2) const
+boolean aff::isa_aff() const
 {
-  auto res = isl_aff_le_basic_set(copy(), aff2.release());
-  return manage(res);
+  return isl::pw_aff(*this).isa_aff();
+}
+
+boolean aff::isa_multi_aff() const
+{
+  return isl::pw_aff(*this).isa_multi_aff();
+}
+
+boolean aff::isa_pw_multi_aff() const
+{
+  return isl::pw_aff(*this).isa_pw_multi_aff();
 }
 
 isl::set aff::le_set(isl::aff aff2) const
 {
   auto res = isl_aff_le_set(copy(), aff2.release());
   return manage(res);
 }
 
-isl::basic_set aff::lt_basic_set(isl::aff aff2) const
+isl::set aff::le_set(const isl::pw_aff &pwaff2) const
 {
-  auto res = isl_aff_lt_basic_set(copy(), aff2.release());
-  return manage(res);
+  return isl::pw_aff(*this).le_set(pwaff2);
+}
+
+isl::aff_list aff::list() const
+{
+  return isl::multi_aff(*this).list();
 }
 
 isl::set aff::lt_set(isl::aff aff2) const
 {
   auto res = isl_aff_lt_set(copy(), aff2.release());
   return manage(res);
 }
 
+isl::set aff::lt_set(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).lt_set(pwaff2);
+}
+
+isl::multi_pw_aff aff::max(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).max(multi2);
+}
+
+isl::pw_aff aff::max(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).max(pwaff2);
+}
+
+isl::multi_val aff::max_multi_val() const
+{
+  return isl::pw_aff(*this).max_multi_val();
+}
+
+isl::multi_pw_aff aff::min(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).min(multi2);
+}
+
+isl::pw_aff aff::min(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).min(pwaff2);
+}
+
+isl::multi_val aff::min_multi_val() const
+{
+  return isl::pw_aff(*this).min_multi_val();
+}
+
 isl::aff aff::mod(isl::val mod) const
 {
   auto res = isl_aff_mod_val(copy(), mod.release());
   return manage(res);
 }
 
-isl::aff aff::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::aff aff::mod(long mod) const
 {
-  auto res = isl_aff_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);
+  return this->mod(isl::val(ctx(), mod));
 }
 
 isl::aff aff::mul(isl::aff aff2) const
 {
   auto res = isl_aff_mul(copy(), aff2.release());
   return manage(res);
 }
 
-isl::aff aff::nan_on_domain(isl::local_space ls)
+isl::pw_aff aff::mul(const isl::pw_aff &pwaff2) const
 {
-  auto res = isl_aff_nan_on_domain(ls.release());
-  return manage(res);
+  return isl::pw_aff(*this).mul(pwaff2);
 }
 
-isl::aff aff::nan_on_domain_space(isl::space space)
+class size aff::n_piece() const
 {
-  auto res = isl_aff_nan_on_domain_space(space.release());
-  return manage(res);
+  return isl::pw_aff(*this).n_piece();
 }
 
 isl::set aff::ne_set(isl::aff aff2) const
 {
   auto res = isl_aff_ne_set(copy(), aff2.release());
   return manage(res);
 }
 
+isl::set aff::ne_set(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).ne_set(pwaff2);
+}
+
 isl::aff aff::neg() const
 {
   auto res = isl_aff_neg(copy());
   return manage(res);
 }
 
-isl::basic_set aff::neg_basic_set() const
+boolean aff::plain_is_empty() const
 {
-  auto res = isl_aff_neg_basic_set(copy());
-  return manage(res);
+  return isl::pw_aff(*this).plain_is_empty();
 }
 
-isl::aff aff::param_on_domain_space_id(isl::space space, isl::id id)
+boolean aff::plain_is_equal(const isl::multi_aff &multi2) const
 {
-  auto res = isl_aff_param_on_domain_space_id(space.release(), id.release());
-  return manage(res);
+  return isl::multi_aff(*this).plain_is_equal(multi2);
 }
 
-boolean aff::plain_is_equal(const isl::aff &aff2) const
+boolean aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_aff_plain_is_equal(get(), aff2.get());
-  return manage(res);
+  return isl::pw_aff(*this).plain_is_equal(multi2);
 }
 
-boolean aff::plain_is_zero() const
+boolean aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_aff_plain_is_zero(get());
-  return manage(res);
+  return isl::pw_aff(*this).plain_is_equal(multi2);
 }
 
-isl::aff aff::project_domain_on_params() const
+isl::pw_multi_aff aff::preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_aff_project_domain_on_params(copy());
-  return manage(res);
+  return isl::pw_aff(*this).preimage_domain_wrapped_domain(pma2);
+}
+
+isl::union_pw_multi_aff aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::multi_aff aff::product(const isl::multi_aff &multi2) const
+{
+  return isl::multi_aff(*this).product(multi2);
+}
+
+isl::multi_pw_aff aff::product(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).product(multi2);
+}
+
+isl::pw_multi_aff aff::product(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_aff(*this).product(pma2);
 }
 
 isl::aff aff::pullback(isl::multi_aff ma) const
 {
   auto res = isl_aff_pullback_multi_aff(copy(), ma.release());
   return manage(res);
 }
 
-isl::aff aff::pullback_aff(isl::aff aff2) const
+isl::pw_aff aff::pullback(const isl::multi_pw_aff &mpa) const
 {
-  auto res = isl_aff_pullback_aff(copy(), aff2.release());
-  return manage(res);
+  return isl::pw_aff(*this).pullback(mpa);
+}
+
+isl::pw_aff aff::pullback(const isl::pw_multi_aff &pma) const
+{
+  return isl::pw_aff(*this).pullback(pma);
+}
+
+isl::union_pw_aff aff::pullback(const isl::union_pw_multi_aff &upma) const
+{
+  return isl::pw_aff(*this).pullback(upma);
+}
+
+isl::aff aff::pullback(const isl::aff &ma) const
+{
+  return this->pullback(isl::multi_aff(ma));
+}
+
+isl::pw_multi_aff_list aff::pw_multi_aff_list() const
+{
+  return isl::pw_aff(*this).pw_multi_aff_list();
+}
+
+isl::pw_multi_aff aff::range_factor_domain() const
+{
+  return isl::pw_aff(*this).range_factor_domain();
+}
+
+isl::pw_multi_aff aff::range_factor_range() const
+{
+  return isl::pw_aff(*this).range_factor_range();
+}
+
+isl::multi_aff aff::range_product(const isl::multi_aff &multi2) const
+{
+  return isl::multi_aff(*this).range_product(multi2);
+}
+
+isl::multi_pw_aff aff::range_product(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).range_product(multi2);
+}
+
+isl::multi_union_pw_aff aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).range_product(multi2);
+}
+
+isl::pw_multi_aff aff::range_product(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_aff(*this).range_product(pma2);
+}
+
+isl::union_pw_multi_aff aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).range_product(upma2);
+}
+
+isl::id aff::range_tuple_id() const
+{
+  return isl::multi_aff(*this).range_tuple_id();
+}
+
+isl::multi_aff aff::reset_range_tuple_id() const
+{
+  return isl::multi_aff(*this).reset_range_tuple_id();
+}
+
+isl::multi_aff aff::reset_tuple_id(isl::dim type) const
+{
+  return isl::multi_aff(*this).reset_tuple_id(type);
 }
 
 isl::aff aff::scale(isl::val v) const
 {
   auto res = isl_aff_scale_val(copy(), v.release());
   return manage(res);
 }
 
+isl::aff aff::scale(long v) const
+{
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_aff aff::scale(const isl::multi_val &mv) const
+{
+  return isl::multi_aff(*this).scale(mv);
+}
+
 isl::aff aff::scale_down(isl::val v) const
 {
   auto res = isl_aff_scale_down_val(copy(), v.release());
   return manage(res);
 }
 
-isl::aff aff::scale_down_ui(unsigned int f) const
+isl::aff aff::scale_down(long v) const
 {
-  auto res = isl_aff_scale_down_ui(copy(), f);
-  return manage(res);
+  return this->scale_down(isl::val(ctx(), v));
 }
 
-isl::aff aff::set_coefficient_si(isl::dim type, int pos, int v) const
+isl::multi_aff aff::scale_down(const isl::multi_val &mv) const
 {
-  auto res = isl_aff_set_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
-  return manage(res);
+  return isl::multi_aff(*this).scale_down(mv);
 }
 
-isl::aff aff::set_coefficient_val(isl::dim type, int pos, isl::val v) const
+isl::multi_aff aff::set_aff(int pos, const isl::aff &el) const
 {
-  auto res = isl_aff_set_coefficient_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
-  return manage(res);
+  return isl::multi_aff(*this).set_aff(pos, el);
+}
+
+isl::multi_aff aff::set_at(int pos, const isl::aff &el) const
+{
+  return isl::multi_aff(*this).set_at(pos, el);
+}
+
+isl::multi_pw_aff aff::set_at(int pos, const isl::pw_aff &el) const
+{
+  return isl::pw_aff(*this).set_at(pos, el);
+}
+
+isl::multi_union_pw_aff aff::set_at(int pos, const isl::union_pw_aff &el) const
+{
+  return isl::pw_aff(*this).set_at(pos, el);
 }
 
 isl::aff aff::set_constant_si(int v) const
 {
   auto res = isl_aff_set_constant_si(copy(), v);
   return manage(res);
 }
 
-isl::aff aff::set_constant_val(isl::val v) const
+isl::multi_pw_aff aff::set_pw_aff(int pos, const isl::pw_aff &el) const
 {
-  auto res = isl_aff_set_constant_val(copy(), v.release());
-  return manage(res);
+  return isl::pw_aff(*this).set_pw_aff(pos, el);
 }
 
-isl::aff aff::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::pw_multi_aff aff::set_pw_aff(unsigned int pos, const isl::pw_aff &pa) const
 {
-  auto res = isl_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return isl::pw_aff(*this).set_pw_aff(pos, pa);
 }
 
-isl::aff aff::set_tuple_id(isl::dim type, isl::id id) const
+isl::multi_aff aff::set_range_tuple(const isl::id &id) const
 {
-  auto res = isl_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
-  return manage(res);
+  return isl::multi_aff(*this).set_range_tuple(id);
+}
+
+isl::multi_aff aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::pw_aff aff::set_tuple_id(isl::dim type, const isl::id &id) const
+{
+  return isl::pw_aff(*this).set_tuple_id(type, id);
+}
+
+isl::pw_aff aff::set_tuple_id(isl::dim type, const std::string &id) const
+{
+  return this->set_tuple_id(type, isl::id(ctx(), id));
+}
+
+isl::multi_union_pw_aff aff::set_union_pw_aff(int pos, const isl::union_pw_aff &el) const
+{
+  return isl::pw_aff(*this).set_union_pw_aff(pos, el);
+}
+
+class size aff::size() const
+{
+  return isl::multi_aff(*this).size();
+}
+
+isl::space aff::space() const
+{
+  return isl::pw_aff(*this).space();
 }
 
 isl::aff aff::sub(isl::aff aff2) const
 {
   auto res = isl_aff_sub(copy(), aff2.release());
   return manage(res);
 }
 
+isl::multi_aff aff::sub(const isl::multi_aff &multi2) const
+{
+  return isl::multi_aff(*this).sub(multi2);
+}
+
+isl::multi_pw_aff aff::sub(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).sub(multi2);
+}
+
+isl::multi_union_pw_aff aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::pw_aff(*this).sub(multi2);
+}
+
+isl::pw_aff aff::sub(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).sub(pwaff2);
+}
+
+isl::pw_multi_aff aff::sub(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_aff(*this).sub(pma2);
+}
+
+isl::union_pw_aff aff::sub(const isl::union_pw_aff &upa2) const
+{
+  return isl::pw_aff(*this).sub(upa2);
+}
+
+isl::union_pw_multi_aff aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).sub(upma2);
+}
+
+isl::pw_aff aff::subtract_domain(const isl::set &set) const
+{
+  return isl::pw_aff(*this).subtract_domain(set);
+}
+
+isl::union_pw_aff aff::subtract_domain(const isl::space &space) const
+{
+  return isl::pw_aff(*this).subtract_domain(space);
+}
+
+isl::union_pw_aff aff::subtract_domain(const isl::union_set &uset) const
+{
+  return isl::pw_aff(*this).subtract_domain(uset);
+}
+
+isl::pw_aff aff::tdiv_q(const isl::pw_aff &pa2) const
+{
+  return isl::pw_aff(*this).tdiv_q(pa2);
+}
+
+isl::pw_aff aff::tdiv_r(const isl::pw_aff &pa2) const
+{
+  return isl::pw_aff(*this).tdiv_r(pa2);
+}
+
+isl::aff_list aff::to_list() const
+{
+  auto res = isl_aff_to_list(copy());
+  return manage(res);
+}
+
+isl::multi_pw_aff aff::to_multi_pw_aff() const
+{
+  return isl::multi_aff(*this).to_multi_pw_aff();
+}
+
+isl::multi_union_pw_aff aff::to_multi_union_pw_aff() const
+{
+  return isl::multi_aff(*this).to_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff aff::to_pw_multi_aff() const
+{
+  return isl::multi_aff(*this).to_pw_multi_aff();
+}
+
+isl::union_pw_aff aff::to_union_pw_aff() const
+{
+  return isl::pw_aff(*this).to_union_pw_aff();
+}
+
+isl::union_pw_multi_aff aff::to_union_pw_multi_aff() const
+{
+  return isl::pw_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::id aff::tuple_id(isl::dim type) const
+{
+  return isl::pw_aff(*this).tuple_id(type);
+}
+
 isl::aff aff::unbind_params_insert_domain(isl::multi_id domain) const
 {
   auto res = isl_aff_unbind_params_insert_domain(copy(), domain.release());
   return manage(res);
 }
 
-isl::aff aff::val_on_domain_space(isl::space space, isl::val val)
+isl::multi_pw_aff aff::union_add(const isl::multi_pw_aff &mpa2) const
 {
-  auto res = isl_aff_val_on_domain_space(space.release(), val.release());
-  return manage(res);
+  return isl::pw_aff(*this).union_add(mpa2);
 }
 
-isl::aff aff::var_on_domain(isl::local_space ls, isl::dim type, unsigned int pos)
+isl::multi_union_pw_aff aff::union_add(const isl::multi_union_pw_aff &mupa2) const
 {
-  auto res = isl_aff_var_on_domain(ls.release(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::pw_aff(*this).union_add(mupa2);
+}
+
+isl::pw_aff aff::union_add(const isl::pw_aff &pwaff2) const
+{
+  return isl::pw_aff(*this).union_add(pwaff2);
+}
+
+isl::pw_multi_aff aff::union_add(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_aff(*this).union_add(pma2);
 }
 
-isl::basic_set aff::zero_basic_set() const
+isl::union_pw_aff aff::union_add(const isl::union_pw_aff &upa2) const
 {
-  auto res = isl_aff_zero_basic_set(copy());
+  return isl::pw_aff(*this).union_add(upa2);
+}
+
+isl::union_pw_multi_aff aff::union_add(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::pw_aff(*this).union_add(upma2);
+}
+
+isl::aff aff::var_on_domain(isl::local_space ls, isl::dim type, unsigned int pos)
+{
+  auto res = isl_aff_var_on_domain(ls.release(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
 isl::aff aff::zero_on_domain(isl::space space)
 {
   auto res = isl_aff_zero_on_domain_space(space.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const aff &obj)
+{
+  char *str = isl_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::aff_list
 aff_list manage(__isl_take isl_aff_list *ptr) {
   return aff_list(ptr);
 }
 aff_list manage_copy(__isl_keep isl_aff_list *ptr) {
   ptr = isl_aff_list_copy(ptr);
   return aff_list(ptr);
 }
 
 aff_list::aff_list()
     : ptr(nullptr) {}
 
 aff_list::aff_list(const aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 aff_list::aff_list(__isl_take isl_aff_list *ptr)
     : ptr(ptr) {}
 
+aff_list::aff_list(isl::ctx ctx, int n)
+{
+  auto res = isl_aff_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+aff_list::aff_list(isl::aff el)
+{
+  auto res = isl_aff_list_from_aff(el.release());
+  ptr = res;
+}
+
+aff_list::aff_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_aff_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 aff_list &aff_list::operator=(aff_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 aff_list::~aff_list() {
   if (ptr)
__isl_give isl_aff_list *aff_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool aff_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx aff_list::ctx() const {
   return isl::ctx(isl_aff_list_get_ctx(ptr));
 }
 
-void aff_list::dump() const {
-  isl_aff_list_dump(get());
-}
-
-
 isl::aff_list aff_list::add(isl::aff el) const
 {
   auto res = isl_aff_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::aff_list aff_list::alloc(isl::ctx ctx, int n)
+isl::aff aff_list::at(int index) const
 {
-  auto res = isl_aff_list_alloc(ctx.release(), n);
+  auto res = isl_aff_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::aff aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::aff_list aff_list::clear() const
 {
   auto res = isl_aff_list_clear(copy());
   return manage(res);
 }
 
 isl::aff_list aff_list::concat(isl::aff_list list2) const
 {
   auto res = isl_aff_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::aff_list aff_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_aff_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat aff_list::foreach(const std::function<stat(aff)> &fn) const
+stat aff_list::foreach(const std::function<stat(isl::aff)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(aff)> *func;
-  } fn_data = { &fn };
+    std::function<stat(isl::aff)> func;
+  } fn_data = { fn };
   auto fn_lambda = [](isl_aff *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_aff_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::aff_list aff_list::from_aff(isl::aff el)
-{
-  auto res = isl_aff_list_from_aff(el.release());
-  return manage(res);
-}
-
-isl::aff aff_list::get_aff(int index) const
-{
-  auto res = isl_aff_list_get_aff(get(), index);
-  return manage(res);
-}
-
-isl::aff aff_list::get_at(int index) const
-{
-  auto res = isl_aff_list_get_at(get(), index);
-  return manage(res);
-}
-
 isl::aff_list aff_list::insert(unsigned int pos, isl::aff el) const
 {
   auto res = isl_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size aff_list::n_aff() const
-{
-  auto res = isl_aff_list_n_aff(get());
-  return res;
-}
-
-isl::aff_list aff_list::reverse() const
-{
-  auto res = isl_aff_list_reverse(copy());
-  return manage(res);
-}
-
-isl::aff_list aff_list::set_aff(int index, isl::aff el) const
-{
-  auto res = isl_aff_list_set_aff(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size aff_list::size() const
+class size aff_list::size() const
 {
   auto res = isl_aff_list_size(get());
-  return res;
+  return manage(res);
 }
 
-isl::aff_list aff_list::swap(unsigned int pos1, unsigned int pos2) const
+inline std::ostream &operator<<(std::ostream &os, const aff_list &obj)
 {
-  auto res = isl_aff_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_aff_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::ast_build
 ast_build manage(__isl_take isl_ast_build *ptr) {
   return ast_build(ptr);
 }
 ast_build manage_copy(__isl_keep isl_ast_build *ptr) {
   ptr = isl_ast_build_copy(ptr);
   return ast_build(ptr);
 }
 
 ast_build::ast_build()
     : ptr(nullptr) {}
 
 ast_build::ast_build(const ast_build &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
+  copy_callbacks(obj);
 }
 
-
 ast_build::ast_build(__isl_take isl_ast_build *ptr)
     : ptr(ptr) {}
 
 ast_build::ast_build(isl::ctx ctx)
 {
   auto res = isl_ast_build_alloc(ctx.release());
   ptr = res;
 }
 
 ast_build &ast_build::operator=(ast_build obj) {
   std::swap(this->ptr, obj.ptr);
+  copy_callbacks(obj);
   return *this;
 }
 
 ast_build::~ast_build() {
   if (ptr)
     isl_ast_build_free(ptr);
 }
 
 __isl_give isl_ast_build *ast_build::copy() const & {
   return isl_ast_build_copy(ptr);
 }
 
 __isl_keep isl_ast_build *ast_build::get() const {
   return ptr;
 }
 
 __isl_give isl_ast_build *ast_build::release() {
+  if (at_each_domain_data)
+    isl_die(ctx().get(), isl_error_invalid, "cannot release object with persistent callbacks", return nullptr);
   isl_ast_build *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_build::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx ast_build::ctx() const {
   return isl::ctx(isl_ast_build_get_ctx(ptr));
 }
 
+ast_build &ast_build::copy_callbacks(const ast_build &obj)
+{
+  at_each_domain_data = obj.at_each_domain_data;
+  return *this;
+}
+
+isl_ast_node *ast_build::at_each_domain(isl_ast_node *arg_0, isl_ast_build *arg_1, void *arg_2)
+{
+  auto *data = static_cast<struct at_each_domain_data *>(arg_2);
+  auto ret = (data->func)(manage(arg_0), manage_copy(arg_1));
+  return ret.release();
+}
+
+void ast_build::set_at_each_domain_data(const std::function<isl::ast_node(isl::ast_node, isl::ast_build)> &fn)
+{
+  at_each_domain_data = std::make_shared<struct at_each_domain_data>();
+  at_each_domain_data->func = fn;
+  ptr = isl_ast_build_set_at_each_domain(ptr, &at_each_domain, at_each_domain_data.get());
+}
+
+isl::ast_build ast_build::set_at_each_domain(const std::function<isl::ast_node(isl::ast_node, isl::ast_build)> &fn) const
+{
+  auto copy = *this;
+  copy.set_at_each_domain_data(fn);
+  return copy;
+}
 
 isl::ast_expr ast_build::access_from(isl::multi_pw_aff mpa) const
 {
   auto res = isl_ast_build_access_from_multi_pw_aff(get(), mpa.release());
   return manage(res);
 }
 
 isl::ast_expr ast_build::access_from(isl::pw_multi_aff pma) const
 {
   auto res = isl_ast_build_access_from_pw_multi_aff(get(), pma.release());
   return manage(res);
 }
 
-isl::ast_node ast_build::ast_from_schedule(isl::union_map schedule) const
-{
-  auto res = isl_ast_build_ast_from_schedule(get(), schedule.release());
-  return manage(res);
-}
-
 isl::ast_expr ast_build::call_from(isl::multi_pw_aff mpa) const
 {
   auto res = isl_ast_build_call_from_multi_pw_aff(get(), mpa.release());
   return manage(res);
 }
 
 isl::ast_expr ast_build::call_from(isl::pw_multi_aff pma) const
 {

 }
 
 isl::ast_build ast_build::from_context(isl::set set)
 {
   auto res = isl_ast_build_from_context(set.release());
   return manage(res);
 }
 
-isl::union_map ast_build::get_schedule() const
-{
-  auto res = isl_ast_build_get_schedule(get());
-  return manage(res);
-}
-
-isl::space ast_build::get_schedule_space() const
-{
-  auto res = isl_ast_build_get_schedule_space(get());
-  return manage(res);
-}
-
 isl::ast_node ast_build::node_from(isl::schedule schedule) const
 {
   auto res = isl_ast_build_node_from_schedule(get(), schedule.release());
   return manage(res);
 }
 
 isl::ast_node ast_build::node_from_schedule_map(isl::union_map schedule) const
 {
   auto res = isl_ast_build_node_from_schedule_map(get(), schedule.release());
   return manage(res);
 }
 
 isl::ast_build ast_build::restrict(isl::set set) const
 {
   auto res = isl_ast_build_restrict(copy(), set.release());
+  return manage(res).copy_callbacks(*this);
+}
+
+isl::union_map ast_build::schedule() const
+{
+  auto res = isl_ast_build_get_schedule(get());
   return manage(res);
 }
 
+isl::union_map ast_build::get_schedule() const
+{
+  return schedule();
+}
+
 // implementations for isl::ast_expr
 ast_expr manage(__isl_take isl_ast_expr *ptr) {
   return ast_expr(ptr);
 }
 ast_expr manage_copy(__isl_keep isl_ast_expr *ptr) {
   ptr = isl_ast_expr_copy(ptr);
   return ast_expr(ptr);
 }
 
 ast_expr::ast_expr()
     : ptr(nullptr) {}
 
 ast_expr::ast_expr(const ast_expr &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 ast_expr::ast_expr(__isl_take isl_ast_expr *ptr)
     : ptr(ptr) {}
 
-
 ast_expr &ast_expr::operator=(ast_expr obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 ast_expr::~ast_expr() {
   if (ptr)
     isl_ast_expr_free(ptr);
__isl_give isl_ast_expr *ast_expr::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_expr::is_null() const {
   return ptr == nullptr;
 }
 
-
-isl::ctx ast_expr::ctx() const {
-  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+template <typename T, typename>
+boolean ast_expr::isa_type(T subtype) const
+{
+  if (is_null())
+    return boolean();
+  return isl_ast_expr_get_type(get()) == subtype;
 }
-
-void ast_expr::dump() const {
-  isl_ast_expr_dump(get());
+template <class T>
+boolean ast_expr::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
 }
-
-
-isl::ast_expr ast_expr::access(isl::ast_expr_list indices) const
+template <class T>
+T ast_expr::as() const
 {
-  auto res = isl_ast_expr_access(copy(), indices.release());
-  return manage(res);
+ if (isa<T>().is_false())
+    isl_die(ctx().get(), isl_error_invalid, "not an object of the requested subtype", return T());
+  return T(copy());
+}
+
+isl::ctx ast_expr::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
 }
 
 isl::ast_expr ast_expr::add(isl::ast_expr expr2) const
 {
   auto res = isl_ast_expr_add(copy(), expr2.release());
   return manage(res);
 }
 
 isl::ast_expr ast_expr::address_of() const
 {
   auto res = isl_ast_expr_address_of(copy());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::call(isl::ast_expr_list arguments) const
+isl::ast_expr ast_expr::eq(isl::ast_expr expr2) const
 {
-  auto res = isl_ast_expr_call(copy(), arguments.release());
+  auto res = isl_ast_expr_eq(copy(), expr2.release());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::div(isl::ast_expr expr2) const
+isl::ast_expr ast_expr::from_val(isl::val v)
 {
-  auto res = isl_ast_expr_div(copy(), expr2.release());
+  auto res = isl_ast_expr_from_val(v.release());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::eq(isl::ast_expr expr2) const
+isl::id ast_expr::id() const
 {
-  auto res = isl_ast_expr_eq(copy(), expr2.release());
+  auto res = isl_ast_expr_get_id(get());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::from_id(isl::id id)
+isl::id ast_expr::get_id() const
 {
-  auto res = isl_ast_expr_from_id(id.release());
-  return manage(res);
+  return id();
 }
 
-isl::ast_expr ast_expr::from_val(isl::val v)
+isl::ast_expr ast_expr::le(isl::ast_expr expr2) const
 {
-  auto res = isl_ast_expr_from_val(v.release());
+  auto res = isl_ast_expr_le(copy(), expr2.release());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::ge(isl::ast_expr expr2) const
+isl::ast_expr ast_expr::mul(isl::ast_expr expr2) const
 {
-  auto res = isl_ast_expr_ge(copy(), expr2.release());
+  auto res = isl_ast_expr_mul(copy(), expr2.release());
   return manage(res);
 }
 
-isl::id ast_expr::get_id() const
+isl::ast_expr ast_expr::op_arg(int pos) const
 {
-  auto res = isl_ast_expr_get_id(get());
+  auto res = isl_ast_expr_get_op_arg(get(), pos);
   return manage(res);
 }
 
 isl::ast_expr ast_expr::get_op_arg(int pos) const
 {
-  auto res = isl_ast_expr_get_op_arg(get(), pos);
-  return manage(res);
+  return op_arg(pos);
 }
 
-isl_size ast_expr::get_op_n_arg() const
+std::string ast_expr::to_C_str() const
 {
-  auto res = isl_ast_expr_get_op_n_arg(get());
-  return res;
+  auto res = isl_ast_expr_to_C_str(get());
+  std::string tmp(res);
+  free(res);
+  return tmp;
 }
 
-isl::val ast_expr::get_val() const
+isl::val ast_expr::val() const
 {
   auto res = isl_ast_expr_get_val(get());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::gt(isl::ast_expr expr2) const
+isl::val ast_expr::get_val() const
 {
-  auto res = isl_ast_expr_gt(copy(), expr2.release());
-  return manage(res);
+  return val();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_id
+ast_expr_id::ast_expr_id()
+    : ast_expr() {}
+
+ast_expr_id::ast_expr_id(const ast_expr_id &obj)
+    : ast_expr(obj)
+{
+}
+
+ast_expr_id::ast_expr_id(__isl_take isl_ast_expr *ptr)
+    : ast_expr(ptr) {}
+
+ast_expr_id &ast_expr_id::operator=(ast_expr_id obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_id::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
 }
 
-isl::id ast_expr::id_get_id() const
+isl::id ast_expr_id::id() const
 {
   auto res = isl_ast_expr_id_get_id(get());
   return manage(res);
 }
 
-isl::val ast_expr::int_get_val() const
+isl::id ast_expr_id::get_id() const
 {
-  auto res = isl_ast_expr_int_get_val(get());
-  return manage(res);
+  return id();
 }
 
-boolean ast_expr::is_equal(const isl::ast_expr &expr2) const
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_id &obj)
 {
-  auto res = isl_ast_expr_is_equal(get(), expr2.get());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_expr ast_expr::le(isl::ast_expr expr2) const
+// implementations for isl::ast_expr_int
+ast_expr_int::ast_expr_int()
+    : ast_expr() {}
+
+ast_expr_int::ast_expr_int(const ast_expr_int &obj)
+    : ast_expr(obj)
 {
-  auto res = isl_ast_expr_le(copy(), expr2.release());
-  return manage(res);
 }
 
-isl::ast_expr ast_expr::lt(isl::ast_expr expr2) const
+ast_expr_int::ast_expr_int(__isl_take isl_ast_expr *ptr)
+    : ast_expr(ptr) {}
+
+ast_expr_int &ast_expr_int::operator=(ast_expr_int obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_int::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+isl::val ast_expr_int::val() const
 {
-  auto res = isl_ast_expr_lt(copy(), expr2.release());
+  auto res = isl_ast_expr_int_get_val(get());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::mul(isl::ast_expr expr2) const
+isl::val ast_expr_int::get_val() const
 {
-  auto res = isl_ast_expr_mul(copy(), expr2.release());
-  return manage(res);
+  return val();
 }
 
-isl::ast_expr ast_expr::neg() const
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_int &obj)
 {
-  auto res = isl_ast_expr_neg(copy());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op
+ast_expr_op::ast_expr_op()
+    : ast_expr() {}
+
+ast_expr_op::ast_expr_op(const ast_expr_op &obj)
+    : ast_expr(obj)
+{
+}
+
+ast_expr_op::ast_expr_op(__isl_take isl_ast_expr *ptr)
+    : ast_expr(ptr) {}
+
+ast_expr_op &ast_expr_op::operator=(ast_expr_op obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+template <typename T, typename>
+boolean ast_expr_op::isa_type(T subtype) const
+{
+  if (is_null())
+    return boolean();
+  return isl_ast_expr_op_get_type(get()) == subtype;
+}
+template <class T>
+boolean ast_expr_op::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T ast_expr_op::as() const
+{
+ if (isa<T>().is_false())
+    isl_die(ctx().get(), isl_error_invalid, "not an object of the requested subtype", return T());
+  return T(copy());
 }
 
-isl::ast_expr ast_expr::op_get_arg(int pos) const
+isl::ctx ast_expr_op::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+isl::ast_expr ast_expr_op::arg(int pos) const
 {
   auto res = isl_ast_expr_op_get_arg(get(), pos);
   return manage(res);
 }
 
-isl_size ast_expr::op_get_n_arg() const
+isl::ast_expr ast_expr_op::get_arg(int pos) const
 {
-  auto res = isl_ast_expr_op_get_n_arg(get());
-  return res;
+  return arg(pos);
 }
 
-isl::ast_expr ast_expr::pdiv_q(isl::ast_expr expr2) const
+class size ast_expr_op::n_arg() const
 {
-  auto res = isl_ast_expr_pdiv_q(copy(), expr2.release());
+  auto res = isl_ast_expr_op_get_n_arg(get());
   return manage(res);
 }
 
-isl::ast_expr ast_expr::pdiv_r(isl::ast_expr expr2) const
+class size ast_expr_op::get_n_arg() const
 {
-  auto res = isl_ast_expr_pdiv_r(copy(), expr2.release());
-  return manage(res);
+  return n_arg();
 }
 
-isl::ast_expr ast_expr::set_op_arg(int pos, isl::ast_expr arg) const
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op &obj)
 {
-  auto res = isl_ast_expr_set_op_arg(copy(), pos, arg.release());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
   }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_access
+ast_expr_op_access::ast_expr_op_access()
+    : ast_expr_op() {}
 
-isl::ast_expr ast_expr::sub(isl::ast_expr expr2) const
+ast_expr_op_access::ast_expr_op_access(const ast_expr_op_access &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_sub(copy(), expr2.release());
-  return manage(res);
 }
 
-isl::ast_expr ast_expr::substitute_ids(isl::id_to_ast_expr id2expr) const
+ast_expr_op_access::ast_expr_op_access(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_access &ast_expr_op_access::operator=(ast_expr_op_access obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_access::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_access &obj)
 {
-  auto res = isl_ast_expr_substitute_ids(copy(), id2expr.release());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-std::string ast_expr::to_C_str() const
+// implementations for isl::ast_expr_op_add
+ast_expr_op_add::ast_expr_op_add()
+    : ast_expr_op() {}
+
+ast_expr_op_add::ast_expr_op_add(const ast_expr_op_add &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_to_C_str(get());
-  std::string tmp(res);
-  free(res);
-  return tmp;
 }
 
-// implementations for isl::ast_expr_list
-ast_expr_list manage(__isl_take isl_ast_expr_list *ptr) {
-  return ast_expr_list(ptr);
+ast_expr_op_add::ast_expr_op_add(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_add &ast_expr_op_add::operator=(ast_expr_op_add obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_add::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_add &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
   }
-ast_expr_list manage_copy(__isl_keep isl_ast_expr_list *ptr) {
-  ptr = isl_ast_expr_list_copy(ptr);
-  return ast_expr_list(ptr);
+  os << str;
+  free(str);
+  return os;
 }
 
-ast_expr_list::ast_expr_list()
-    : ptr(nullptr) {}
+// implementations for isl::ast_expr_op_address_of
+ast_expr_op_address_of::ast_expr_op_address_of()
+    : ast_expr_op() {}
 
-ast_expr_list::ast_expr_list(const ast_expr_list &obj)
-    : ptr(nullptr)
+ast_expr_op_address_of::ast_expr_op_address_of(const ast_expr_op_address_of &obj)
+    : ast_expr_op(obj)
 {
-  ptr = obj.copy();
 }
 
+ast_expr_op_address_of::ast_expr_op_address_of(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
 
-ast_expr_list::ast_expr_list(__isl_take isl_ast_expr_list *ptr)
-    : ptr(ptr) {}
+ast_expr_op_address_of &ast_expr_op_address_of::operator=(ast_expr_op_address_of obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_address_of::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_address_of &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_and
+ast_expr_op_and::ast_expr_op_and()
+    : ast_expr_op() {}
+
+ast_expr_op_and::ast_expr_op_and(const ast_expr_op_and &obj)
+    : ast_expr_op(obj)
+{
+}
 
+ast_expr_op_and::ast_expr_op_and(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
 
-ast_expr_list &ast_expr_list::operator=(ast_expr_list obj) {
+ast_expr_op_and &ast_expr_op_and::operator=(ast_expr_op_and obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
-ast_expr_list::~ast_expr_list() {
-  if (ptr)
-    isl_ast_expr_list_free(ptr);
+isl::ctx ast_expr_op_and::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
 }
 
-__isl_give isl_ast_expr_list *ast_expr_list::copy() const & {
-  return isl_ast_expr_list_copy(ptr);
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_and &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-__isl_keep isl_ast_expr_list *ast_expr_list::get() const {
-  return ptr;
+// implementations for isl::ast_expr_op_and_then
+ast_expr_op_and_then::ast_expr_op_and_then()
+    : ast_expr_op() {}
+
+ast_expr_op_and_then::ast_expr_op_and_then(const ast_expr_op_and_then &obj)
+    : ast_expr_op(obj)
+{
 }
 
-__isl_give isl_ast_expr_list *ast_expr_list::release() {
-  isl_ast_expr_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+ast_expr_op_and_then::ast_expr_op_and_then(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_and_then &ast_expr_op_and_then::operator=(ast_expr_op_and_then obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
 }
 
-bool ast_expr_list::is_null() const {
-  return ptr == nullptr;
+isl::ctx ast_expr_op_and_then::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_and_then &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
+// implementations for isl::ast_expr_op_call
+ast_expr_op_call::ast_expr_op_call()
+    : ast_expr_op() {}
 
-isl::ctx ast_expr_list::ctx() const {
-  return isl::ctx(isl_ast_expr_list_get_ctx(ptr));
+ast_expr_op_call::ast_expr_op_call(const ast_expr_op_call &obj)
+    : ast_expr_op(obj)
+{
 }
 
-void ast_expr_list::dump() const {
-  isl_ast_expr_list_dump(get());
+ast_expr_op_call::ast_expr_op_call(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_call &ast_expr_op_call::operator=(ast_expr_op_call obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
 }
 
+isl::ctx ast_expr_op_call::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
 
-isl::ast_expr_list ast_expr_list::add(isl::ast_expr el) const
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_call &obj)
 {
-  auto res = isl_ast_expr_list_add(copy(), el.release());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_expr_list ast_expr_list::alloc(isl::ctx ctx, int n)
+// implementations for isl::ast_expr_op_cond
+ast_expr_op_cond::ast_expr_op_cond()
+    : ast_expr_op() {}
+
+ast_expr_op_cond::ast_expr_op_cond(const ast_expr_op_cond &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_list_alloc(ctx.release(), n);
-  return manage(res);
 }
 
-isl::ast_expr_list ast_expr_list::clear() const
+ast_expr_op_cond::ast_expr_op_cond(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_cond &ast_expr_op_cond::operator=(ast_expr_op_cond obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_cond::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_cond &obj)
 {
-  auto res = isl_ast_expr_list_clear(copy());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_expr_list ast_expr_list::concat(isl::ast_expr_list list2) const
+// implementations for isl::ast_expr_op_div
+ast_expr_op_div::ast_expr_op_div()
+    : ast_expr_op() {}
+
+ast_expr_op_div::ast_expr_op_div(const ast_expr_op_div &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_list_concat(copy(), list2.release());
-  return manage(res);
 }
 
-isl::ast_expr_list ast_expr_list::drop(unsigned int first, unsigned int n) const
+ast_expr_op_div::ast_expr_op_div(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_div &ast_expr_op_div::operator=(ast_expr_op_div obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_div::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_div &obj)
 {
-  auto res = isl_ast_expr_list_drop(copy(), first, n);
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-stat ast_expr_list::foreach(const std::function<stat(ast_expr)> &fn) const
+// implementations for isl::ast_expr_op_eq
+ast_expr_op_eq::ast_expr_op_eq()
+    : ast_expr_op() {}
+
+ast_expr_op_eq::ast_expr_op_eq(const ast_expr_op_eq &obj)
+    : ast_expr_op(obj)
 {
-  struct fn_data {
-    const std::function<stat(ast_expr)> *func;
-  } fn_data = { &fn };
-  auto fn_lambda = [](isl_ast_expr *arg_0, void *arg_1) -> isl_stat {
-    auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_ast_expr_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
 }
 
-isl::ast_expr_list ast_expr_list::from_ast_expr(isl::ast_expr el)
+ast_expr_op_eq::ast_expr_op_eq(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_eq &ast_expr_op_eq::operator=(ast_expr_op_eq obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_eq::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_eq &obj)
 {
-  auto res = isl_ast_expr_list_from_ast_expr(el.release());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_expr ast_expr_list::get_ast_expr(int index) const
+// implementations for isl::ast_expr_op_fdiv_q
+ast_expr_op_fdiv_q::ast_expr_op_fdiv_q()
+    : ast_expr_op() {}
+
+ast_expr_op_fdiv_q::ast_expr_op_fdiv_q(const ast_expr_op_fdiv_q &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_list_get_ast_expr(get(), index);
-  return manage(res);
 }
 
-isl::ast_expr ast_expr_list::get_at(int index) const
+ast_expr_op_fdiv_q::ast_expr_op_fdiv_q(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_fdiv_q &ast_expr_op_fdiv_q::operator=(ast_expr_op_fdiv_q obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_fdiv_q::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_fdiv_q &obj)
 {
-  auto res = isl_ast_expr_list_get_at(get(), index);
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_expr_list ast_expr_list::insert(unsigned int pos, isl::ast_expr el) const
+// implementations for isl::ast_expr_op_ge
+ast_expr_op_ge::ast_expr_op_ge()
+    : ast_expr_op() {}
+
+ast_expr_op_ge::ast_expr_op_ge(const ast_expr_op_ge &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_list_insert(copy(), pos, el.release());
-  return manage(res);
 }
 
-isl_size ast_expr_list::n_ast_expr() const
+ast_expr_op_ge::ast_expr_op_ge(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_ge &ast_expr_op_ge::operator=(ast_expr_op_ge obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_ge::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_ge &obj)
 {
-  auto res = isl_ast_expr_list_n_ast_expr(get());
-  return res;
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_expr_list ast_expr_list::reverse() const
+// implementations for isl::ast_expr_op_gt
+ast_expr_op_gt::ast_expr_op_gt()
+    : ast_expr_op() {}
+
+ast_expr_op_gt::ast_expr_op_gt(const ast_expr_op_gt &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_list_reverse(copy());
-  return manage(res);
 }
 
-isl::ast_expr_list ast_expr_list::set_ast_expr(int index, isl::ast_expr el) const
+ast_expr_op_gt::ast_expr_op_gt(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_gt &ast_expr_op_gt::operator=(ast_expr_op_gt obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_gt::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_gt &obj)
 {
-  auto res = isl_ast_expr_list_set_ast_expr(copy(), index, el.release());
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl_size ast_expr_list::size() const
+// implementations for isl::ast_expr_op_le
+ast_expr_op_le::ast_expr_op_le()
+    : ast_expr_op() {}
+
+ast_expr_op_le::ast_expr_op_le(const ast_expr_op_le &obj)
+    : ast_expr_op(obj)
 {
-  auto res = isl_ast_expr_list_size(get());
-  return res;
 }
 
-isl::ast_expr_list ast_expr_list::swap(unsigned int pos1, unsigned int pos2) const
+ast_expr_op_le::ast_expr_op_le(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_le &ast_expr_op_le::operator=(ast_expr_op_le obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_le::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_le &obj)
 {
-  auto res = isl_ast_expr_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_lt
+ast_expr_op_lt::ast_expr_op_lt()
+    : ast_expr_op() {}
+
+ast_expr_op_lt::ast_expr_op_lt(const ast_expr_op_lt &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_lt::ast_expr_op_lt(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_lt &ast_expr_op_lt::operator=(ast_expr_op_lt obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_lt::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_lt &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_max
+ast_expr_op_max::ast_expr_op_max()
+    : ast_expr_op() {}
+
+ast_expr_op_max::ast_expr_op_max(const ast_expr_op_max &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_max::ast_expr_op_max(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_max &ast_expr_op_max::operator=(ast_expr_op_max obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_max::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_max &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_member
+ast_expr_op_member::ast_expr_op_member()
+    : ast_expr_op() {}
+
+ast_expr_op_member::ast_expr_op_member(const ast_expr_op_member &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_member::ast_expr_op_member(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_member &ast_expr_op_member::operator=(ast_expr_op_member obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_member::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_member &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_min
+ast_expr_op_min::ast_expr_op_min()
+    : ast_expr_op() {}
+
+ast_expr_op_min::ast_expr_op_min(const ast_expr_op_min &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_min::ast_expr_op_min(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_min &ast_expr_op_min::operator=(ast_expr_op_min obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_min::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_min &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_minus
+ast_expr_op_minus::ast_expr_op_minus()
+    : ast_expr_op() {}
+
+ast_expr_op_minus::ast_expr_op_minus(const ast_expr_op_minus &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_minus::ast_expr_op_minus(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_minus &ast_expr_op_minus::operator=(ast_expr_op_minus obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_minus::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_minus &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_mul
+ast_expr_op_mul::ast_expr_op_mul()
+    : ast_expr_op() {}
+
+ast_expr_op_mul::ast_expr_op_mul(const ast_expr_op_mul &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_mul::ast_expr_op_mul(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_mul &ast_expr_op_mul::operator=(ast_expr_op_mul obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_mul::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_mul &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_or
+ast_expr_op_or::ast_expr_op_or()
+    : ast_expr_op() {}
+
+ast_expr_op_or::ast_expr_op_or(const ast_expr_op_or &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_or::ast_expr_op_or(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_or &ast_expr_op_or::operator=(ast_expr_op_or obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_or::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_or &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_or_else
+ast_expr_op_or_else::ast_expr_op_or_else()
+    : ast_expr_op() {}
+
+ast_expr_op_or_else::ast_expr_op_or_else(const ast_expr_op_or_else &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_or_else::ast_expr_op_or_else(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_or_else &ast_expr_op_or_else::operator=(ast_expr_op_or_else obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_or_else::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_or_else &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_pdiv_q
+ast_expr_op_pdiv_q::ast_expr_op_pdiv_q()
+    : ast_expr_op() {}
+
+ast_expr_op_pdiv_q::ast_expr_op_pdiv_q(const ast_expr_op_pdiv_q &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_pdiv_q::ast_expr_op_pdiv_q(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_pdiv_q &ast_expr_op_pdiv_q::operator=(ast_expr_op_pdiv_q obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_pdiv_q::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_pdiv_q &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_pdiv_r
+ast_expr_op_pdiv_r::ast_expr_op_pdiv_r()
+    : ast_expr_op() {}
+
+ast_expr_op_pdiv_r::ast_expr_op_pdiv_r(const ast_expr_op_pdiv_r &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_pdiv_r::ast_expr_op_pdiv_r(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_pdiv_r &ast_expr_op_pdiv_r::operator=(ast_expr_op_pdiv_r obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_pdiv_r::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_pdiv_r &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_select
+ast_expr_op_select::ast_expr_op_select()
+    : ast_expr_op() {}
+
+ast_expr_op_select::ast_expr_op_select(const ast_expr_op_select &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_select::ast_expr_op_select(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_select &ast_expr_op_select::operator=(ast_expr_op_select obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_select::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_select &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_sub
+ast_expr_op_sub::ast_expr_op_sub()
+    : ast_expr_op() {}
+
+ast_expr_op_sub::ast_expr_op_sub(const ast_expr_op_sub &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_sub::ast_expr_op_sub(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_sub &ast_expr_op_sub::operator=(ast_expr_op_sub obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_sub::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_sub &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_zdiv_r
+ast_expr_op_zdiv_r::ast_expr_op_zdiv_r()
+    : ast_expr_op() {}
+
+ast_expr_op_zdiv_r::ast_expr_op_zdiv_r(const ast_expr_op_zdiv_r &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_zdiv_r::ast_expr_op_zdiv_r(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(ptr) {}
+
+ast_expr_op_zdiv_r &ast_expr_op_zdiv_r::operator=(ast_expr_op_zdiv_r obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_zdiv_r::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_zdiv_r &obj)
+{
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::ast_node
 ast_node manage(__isl_take isl_ast_node *ptr) {
   return ast_node(ptr);
 }
 ast_node manage_copy(__isl_keep isl_ast_node *ptr) {
   ptr = isl_ast_node_copy(ptr);
   return ast_node(ptr);
 }
 
 ast_node::ast_node()
     : ptr(nullptr) {}
 
 ast_node::ast_node(const ast_node &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 ast_node::ast_node(__isl_take isl_ast_node *ptr)
     : ptr(ptr) {}
 
-
 ast_node &ast_node::operator=(ast_node obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 ast_node::~ast_node() {
   if (ptr)
     isl_ast_node_free(ptr);
__isl_give isl_ast_node *ast_node::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_node::is_null() const {
   return ptr == nullptr;
 }
 
+template <typename T, typename>
+boolean ast_node::isa_type(T subtype) const
+{
+  if (is_null())
+    return boolean();
+  return isl_ast_node_get_type(get()) == subtype;
+}
+template <class T>
+boolean ast_node::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T ast_node::as() const
+{
+ if (isa<T>().is_false())
+    isl_die(ctx().get(), isl_error_invalid, "not an object of the requested subtype", return T());
+  return T(copy());
+}
 
 isl::ctx ast_node::ctx() const {
   return isl::ctx(isl_ast_node_get_ctx(ptr));
 }
 
-void ast_node::dump() const {
-  isl_ast_node_dump(get());
+isl::id ast_node::annotation() const
+{
+  auto res = isl_ast_node_get_annotation(get());
+  return manage(res);
+}
+
+isl::id ast_node::get_annotation() const
+{
+  return annotation();
 }
 
+std::string ast_node::to_C_str() const
+{
+  auto res = isl_ast_node_to_C_str(get());
+  std::string tmp(res);
+  free(res);
+  return tmp;
+}
 
-isl::ast_node ast_node::alloc_user(isl::ast_expr expr)
+isl::ast_node_list ast_node::to_list() const
 {
-  auto res = isl_ast_node_alloc_user(expr.release());
+  auto res = isl_ast_node_to_list(copy());
   return manage(res);
 }
 
-isl::ast_node_list ast_node::block_get_children() const
+inline std::ostream &operator<<(std::ostream &os, const ast_node &obj)
+{
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_node_block
+ast_node_block::ast_node_block()
+    : ast_node() {}
+
+ast_node_block::ast_node_block(const ast_node_block &obj)
+    : ast_node(obj)
+{
+}
+
+ast_node_block::ast_node_block(__isl_take isl_ast_node *ptr)
+    : ast_node(ptr) {}
+
+ast_node_block &ast_node_block::operator=(ast_node_block obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_node_block::ctx() const {
+  return isl::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::ast_node_list ast_node_block::children() const
 {
   auto res = isl_ast_node_block_get_children(get());
   return manage(res);
 }
 
-isl::ast_node ast_node::for_get_body() const
+isl::ast_node_list ast_node_block::get_children() const
+{
+  return children();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_block &obj)
+{
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_node_for
+ast_node_for::ast_node_for()
+    : ast_node() {}
+
+ast_node_for::ast_node_for(const ast_node_for &obj)
+    : ast_node(obj)
+{
+}
+
+ast_node_for::ast_node_for(__isl_take isl_ast_node *ptr)
+    : ast_node(ptr) {}
+
+ast_node_for &ast_node_for::operator=(ast_node_for obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_node_for::ctx() const {
+  return isl::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::ast_node ast_node_for::body() const
 {
   auto res = isl_ast_node_for_get_body(get());
   return manage(res);
 }
 
-isl::ast_expr ast_node::for_get_cond() const
+isl::ast_node ast_node_for::get_body() const
+{
+  return body();
+}
+
+isl::ast_expr ast_node_for::cond() const
 {
   auto res = isl_ast_node_for_get_cond(get());
   return manage(res);
 }
 
-isl::ast_expr ast_node::for_get_inc() const
+isl::ast_expr ast_node_for::get_cond() const
+{
+  return cond();
+}
+
+isl::ast_expr ast_node_for::inc() const
 {
   auto res = isl_ast_node_for_get_inc(get());
   return manage(res);
 }
 
-isl::ast_expr ast_node::for_get_init() const
+isl::ast_expr ast_node_for::get_inc() const
+{
+  return inc();
+}
+
+isl::ast_expr ast_node_for::init() const
 {
   auto res = isl_ast_node_for_get_init(get());
   return manage(res);
 }
 
-isl::ast_expr ast_node::for_get_iterator() const
+isl::ast_expr ast_node_for::get_init() const
 {
-  auto res = isl_ast_node_for_get_iterator(get());
-  return manage(res);
+  return init();
 }
 
-boolean ast_node::for_is_degenerate() const
+boolean ast_node_for::is_degenerate() const
 {
   auto res = isl_ast_node_for_is_degenerate(get());
   return manage(res);
 }
 
-isl::id ast_node::get_annotation() const
+isl::ast_expr ast_node_for::iterator() const
 {
-  auto res = isl_ast_node_get_annotation(get());
+  auto res = isl_ast_node_for_get_iterator(get());
   return manage(res);
 }
 
-isl::ast_expr ast_node::if_get_cond() const
+isl::ast_expr ast_node_for::get_iterator() const
 {
-  auto res = isl_ast_node_if_get_cond(get());
-  return manage(res);
+  return iterator();
 }
 
-isl::ast_node ast_node::if_get_else() const
+inline std::ostream &operator<<(std::ostream &os, const ast_node_for &obj)
 {
-  auto res = isl_ast_node_if_get_else(get());
-  return manage(res);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_node ast_node::if_get_else_node() const
+// implementations for isl::ast_node_if
+ast_node_if::ast_node_if()
+    : ast_node() {}
+
+ast_node_if::ast_node_if(const ast_node_if &obj)
+    : ast_node(obj)
 {
-  auto res = isl_ast_node_if_get_else_node(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);
+ast_node_if::ast_node_if(__isl_take isl_ast_node *ptr)
+    : ast_node(ptr) {}
+
+ast_node_if &ast_node_if::operator=(ast_node_if obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_node_if::ctx() const {
+  return isl::ctx(isl_ast_node_get_ctx(ptr));
 }
 
-isl::ast_node ast_node::if_get_then_node() const
+isl::ast_expr ast_node_if::cond() const
 {
-  auto res = isl_ast_node_if_get_then_node(get());
+  auto res = isl_ast_node_if_get_cond(get());
   return manage(res);
 }
 
-boolean ast_node::if_has_else() const
+isl::ast_expr ast_node_if::get_cond() const
 {
-  auto res = isl_ast_node_if_has_else(get());
-  return manage(res);
+  return cond();
 }
 
-boolean ast_node::if_has_else_node() const
+isl::ast_node ast_node_if::else_node() const
 {
-  auto res = isl_ast_node_if_has_else_node(get());
+  auto res = isl_ast_node_if_get_else_node(get());
   return manage(res);
 }
 
-isl::id ast_node::mark_get_id() const
+isl::ast_node ast_node_if::get_else_node() const
 {
-  auto res = isl_ast_node_mark_get_id(get());
-  return manage(res);
+  return else_node();
 }
 
-isl::ast_node ast_node::mark_get_node() const
+boolean ast_node_if::has_else_node() const
 {
-  auto res = isl_ast_node_mark_get_node(get());
+  auto res = isl_ast_node_if_has_else_node(get());
   return manage(res);
 }
 
-isl::ast_node ast_node::set_annotation(isl::id annotation) const
+isl::ast_node ast_node_if::then_node() const
 {
-  auto res = isl_ast_node_set_annotation(copy(), annotation.release());
+  auto res = isl_ast_node_if_get_then_node(get());
   return manage(res);
 }
 
-std::string ast_node::to_C_str() const
+isl::ast_node ast_node_if::get_then_node() const
 {
-  auto res = isl_ast_node_to_C_str(get());
-  std::string tmp(res);
-  free(res);
-  return tmp;
+  return then_node();
 }
 
-isl::ast_expr ast_node::user_get_expr() const
+inline std::ostream &operator<<(std::ostream &os, const ast_node_if &obj)
 {
-  auto res = isl_ast_node_user_get_expr(get());
-  return manage(res);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::ast_node_list
 ast_node_list manage(__isl_take isl_ast_node_list *ptr) {
   return ast_node_list(ptr);
 }
 ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr) {
   ptr = isl_ast_node_list_copy(ptr);
   return ast_node_list(ptr);
 }
 
 ast_node_list::ast_node_list()
     : ptr(nullptr) {}
 
 ast_node_list::ast_node_list(const ast_node_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 ast_node_list::ast_node_list(__isl_take isl_ast_node_list *ptr)
     : ptr(ptr) {}
 
+ast_node_list::ast_node_list(isl::ctx ctx, int n)
+{
+  auto res = isl_ast_node_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+ast_node_list::ast_node_list(isl::ast_node el)
+{
+  auto res = isl_ast_node_list_from_ast_node(el.release());
+  ptr = res;
+}
 
 ast_node_list &ast_node_list::operator=(ast_node_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 ast_node_list::~ast_node_list() {
   if (ptr)
__isl_give isl_ast_node_list *ast_node_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_node_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx ast_node_list::ctx() const {
   return isl::ctx(isl_ast_node_list_get_ctx(ptr));
 }
 
-void ast_node_list::dump() const {
-  isl_ast_node_list_dump(get());
-}
-
-
 isl::ast_node_list ast_node_list::add(isl::ast_node el) const
 {
   auto res = isl_ast_node_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::ast_node_list ast_node_list::alloc(isl::ctx ctx, int n)
+isl::ast_node ast_node_list::at(int index) const
 {
-  auto res = isl_ast_node_list_alloc(ctx.release(), n);
+  auto res = isl_ast_node_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::ast_node ast_node_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::ast_node_list ast_node_list::clear() const
 {
   auto res = isl_ast_node_list_clear(copy());
   return manage(res);
 }
 
 isl::ast_node_list ast_node_list::concat(isl::ast_node_list list2) const
 {
   auto res = isl_ast_node_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::ast_node_list ast_node_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_ast_node_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat ast_node_list::foreach(const std::function<stat(ast_node)> &fn) const
+stat ast_node_list::foreach(const std::function<stat(isl::ast_node)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(ast_node)> *func;
-  } fn_data = { &fn };
+    std::function<stat(isl::ast_node)> func;
+  } fn_data = { fn };
   auto fn_lambda = [](isl_ast_node *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_ast_node_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::ast_node_list ast_node_list::from_ast_node(isl::ast_node el)
+isl::ast_node_list ast_node_list::insert(unsigned int pos, isl::ast_node el) const
 {
-  auto res = isl_ast_node_list_from_ast_node(el.release());
+  auto res = isl_ast_node_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::ast_node ast_node_list::get_ast_node(int index) const
+class size ast_node_list::size() const
 {
-  auto res = isl_ast_node_list_get_ast_node(get(), index);
+  auto res = isl_ast_node_list_size(get());
   return manage(res);
 }
 
-isl::ast_node ast_node_list::get_at(int index) const
+inline std::ostream &operator<<(std::ostream &os, const ast_node_list &obj)
 {
-  auto res = isl_ast_node_list_get_at(get(), index);
-  return manage(res);
+  char *str = isl_ast_node_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_node_list ast_node_list::insert(unsigned int pos, isl::ast_node el) const
+// implementations for isl::ast_node_mark
+ast_node_mark::ast_node_mark()
+    : ast_node() {}
+
+ast_node_mark::ast_node_mark(const ast_node_mark &obj)
+    : ast_node(obj)
 {
-  auto res = isl_ast_node_list_insert(copy(), pos, el.release());
+}
+
+ast_node_mark::ast_node_mark(__isl_take isl_ast_node *ptr)
+    : ast_node(ptr) {}
+
+ast_node_mark &ast_node_mark::operator=(ast_node_mark obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_node_mark::ctx() const {
+  return isl::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::id ast_node_mark::id() const
+{
+  auto res = isl_ast_node_mark_get_id(get());
   return manage(res);
 }
 
-isl_size ast_node_list::n_ast_node() const
+isl::id ast_node_mark::get_id() const
 {
-  auto res = isl_ast_node_list_n_ast_node(get());
-  return res;
+  return id();
 }
 
-isl::ast_node_list ast_node_list::reverse() const
+isl::ast_node ast_node_mark::node() const
 {
-  auto res = isl_ast_node_list_reverse(copy());
+  auto res = isl_ast_node_mark_get_node(get());
   return manage(res);
 }
 
-isl::ast_node_list ast_node_list::set_ast_node(int index, isl::ast_node el) const
+isl::ast_node ast_node_mark::get_node() const
 {
-  auto res = isl_ast_node_list_set_ast_node(copy(), index, el.release());
-  return manage(res);
+  return node();
 }
 
-isl_size ast_node_list::size() const
+inline std::ostream &operator<<(std::ostream &os, const ast_node_mark &obj)
 {
-  auto res = isl_ast_node_list_size(get());
-  return res;
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::ast_node_list ast_node_list::swap(unsigned int pos1, unsigned int pos2) const
+// implementations for isl::ast_node_user
+ast_node_user::ast_node_user()
+    : ast_node() {}
+
+ast_node_user::ast_node_user(const ast_node_user &obj)
+    : ast_node(obj)
+{
+}
+
+ast_node_user::ast_node_user(__isl_take isl_ast_node *ptr)
+    : ast_node(ptr) {}
+
+ast_node_user &ast_node_user::operator=(ast_node_user obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_node_user::ctx() const {
+  return isl::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::ast_expr ast_node_user::expr() const
 {
-  auto res = isl_ast_node_list_swap(copy(), pos1, pos2);
+  auto res = isl_ast_node_user_get_expr(get());
   return manage(res);
 }
 
+isl::ast_expr ast_node_user::get_expr() const
+{
+  return expr();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_user &obj)
+{
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::basic_map
 basic_map manage(__isl_take isl_basic_map *ptr) {
   return basic_map(ptr);
 }
 basic_map manage_copy(__isl_keep isl_basic_map *ptr) {
   ptr = isl_basic_map_copy(ptr);
   return basic_map(ptr);
 }
 
 basic_map::basic_map()
     : ptr(nullptr) {}
 
 basic_map::basic_map(const basic_map &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 basic_map::basic_map(__isl_take isl_basic_map *ptr)
     : ptr(ptr) {}
 
 basic_map::basic_map(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_basic_map_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
__isl_give isl_basic_map *basic_map::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_map::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx basic_map::ctx() const {
   return isl::ctx(isl_basic_map_get_ctx(ptr));
 }
 
-void basic_map::dump() const {
-  isl_basic_map_dump(get());
-}
-
-
-isl::basic_map basic_map::add_constraint(isl::constraint constraint) const
+isl::map basic_map::add_constraint(const isl::constraint &constraint) const
 {
-  auto res = isl_basic_map_add_constraint(copy(), constraint.release());
-  return manage(res);
+  return isl::map(*this).add_constraint(constraint);
 }
 
-isl::basic_map basic_map::add_dims(isl::dim type, unsigned int n) const
+isl::map basic_map::add_dims(isl::dim type, unsigned int n) const
 {
-  auto res = isl_basic_map_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return isl::map(*this).add_dims(type, n);
 }
 
 isl::basic_map basic_map::affine_hull() const
 {
   auto res = isl_basic_map_affine_hull(copy());
   return manage(res);
 }
 
-isl::basic_map basic_map::align_params(isl::space model) const
+isl::map basic_map::align_params(const isl::space &model) const
 {
-  auto res = isl_basic_map_align_params(copy(), model.release());
-  return manage(res);
+  return isl::map(*this).align_params(model);
 }
 
 isl::basic_map basic_map::apply_domain(isl::basic_map bmap2) const
 {
   auto res = isl_basic_map_apply_domain(copy(), bmap2.release());
   return manage(res);
 }
 
+isl::map basic_map::apply_domain(const isl::map &map2) const
+{
+  return isl::map(*this).apply_domain(map2);
+}
+
+isl::union_map basic_map::apply_domain(const isl::union_map &umap2) const
+{
+  return isl::map(*this).apply_domain(umap2);
+}
+
 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::map basic_map::apply_range(const isl::map &map2) const
+{
+  return isl::map(*this).apply_range(map2);
+}
+
+isl::union_map basic_map::apply_range(const isl::union_map &umap2) const
+{
+  return isl::map(*this).apply_range(umap2);
+}
+
+isl::map basic_map::as_map() const
+{
+  return isl::map(*this).as_map();
+}
+
+isl::multi_union_pw_aff basic_map::as_multi_union_pw_aff() const
+{
+  return isl::map(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff basic_map::as_pw_multi_aff() const
+{
+  return isl::map(*this).as_pw_multi_aff();
+}
+
+isl::union_pw_multi_aff basic_map::as_union_pw_multi_aff() const
+{
+  return isl::map(*this).as_union_pw_multi_aff();
+}
+
+isl::basic_map_list basic_map::basic_map_list() const
+{
+  return isl::map(*this).basic_map_list();
+}
+
+isl::set basic_map::bind_domain(const isl::multi_id &tuple) const
+{
+  return isl::map(*this).bind_domain(tuple);
+}
+
+isl::set basic_map::bind_range(const isl::multi_id &tuple) const
+{
+  return isl::map(*this).bind_range(tuple);
+}
+
 boolean basic_map::can_curry() const
 {
-  auto res = isl_basic_map_can_curry(get());
-  return manage(res);
+  return isl::map(*this).can_curry();
 }
 
-boolean basic_map::can_uncurry() const
+isl::map basic_map::coalesce() const
 {
-  auto res = isl_basic_map_can_uncurry(get());
-  return manage(res);
+  return isl::map(*this).coalesce();
 }
 
-boolean basic_map::can_zip() const
+isl::map basic_map::complement() const
 {
-  auto res = isl_basic_map_can_zip(get());
-  return manage(res);
+  return isl::map(*this).complement();
 }
 
-isl::basic_map basic_map::curry() const
+isl::union_map basic_map::compute_divs() const
 {
-  auto res = isl_basic_map_curry(copy());
-  return manage(res);
+  return isl::map(*this).compute_divs();
 }
 
-isl::basic_set basic_map::deltas() const
+isl::map basic_map::curry() const
 {
-  auto res = isl_basic_map_deltas(copy());
-  return manage(res);
+  return isl::map(*this).curry();
 }
 
-isl::basic_map basic_map::deltas_map() const
+isl::basic_set basic_map::deltas() const
 {
-  auto res = isl_basic_map_deltas_map(copy());
+  auto res = isl_basic_map_deltas(copy());
   return manage(res);
 }
 
 isl::basic_map basic_map::detect_equalities() const
 {
   auto res = isl_basic_map_detect_equalities(copy());
   return manage(res);
 }
 
-isl_size basic_map::dim(isl::dim type) const
+class size basic_map::dim(isl::dim type) const
 {
-  auto res = isl_basic_map_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::map(*this).dim(type);
+}
+
+isl::pw_aff basic_map::dim_max(int pos) const
+{
+  return isl::map(*this).dim_max(pos);
+}
+
+isl::pw_aff basic_map::dim_min(int pos) const
+{
+  return isl::map(*this).dim_min(pos);
 }
 
 isl::basic_set basic_map::domain() const
 {
   auto res = isl_basic_map_domain(copy());
   return manage(res);
 }
 
-isl::basic_map basic_map::domain_map() const
+isl::map basic_map::domain_factor_domain() const
 {
-  auto res = isl_basic_map_domain_map(copy());
-  return manage(res);
+  return isl::map(*this).domain_factor_domain();
 }
 
-isl::basic_map basic_map::domain_product(isl::basic_map bmap2) const
+isl::map basic_map::domain_factor_range() const
 {
-  auto res = isl_basic_map_domain_product(copy(), bmap2.release());
-  return manage(res);
+  return isl::map(*this).domain_factor_range();
 }
 
-isl::basic_map basic_map::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::map basic_map::domain_map() const
 {
-  auto res = isl_basic_map_drop_constraints_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).domain_map();
 }
 
-isl::basic_map basic_map::drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_pw_multi_aff basic_map::domain_map_union_pw_multi_aff() const
 {
-  auto res = isl_basic_map_drop_constraints_not_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).domain_map_union_pw_multi_aff();
 }
 
-isl::basic_map basic_map::drop_unused_params() const
+isl::map basic_map::domain_product(const isl::map &map2) const
 {
-  auto res = isl_basic_map_drop_unused_params(copy());
-  return manage(res);
+  return isl::map(*this).domain_product(map2);
 }
 
-isl::basic_map basic_map::eliminate(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_map basic_map::domain_product(const isl::union_map &umap2) const
 {
-  auto res = isl_basic_map_eliminate(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).domain_product(umap2);
 }
 
-isl::basic_map basic_map::empty(isl::space space)
+class size basic_map::domain_tuple_dim() const
 {
-  auto res = isl_basic_map_empty(space.release());
-  return manage(res);
+  return isl::map(*this).domain_tuple_dim();
 }
 
-isl::basic_map basic_map::equal(isl::space space, unsigned int n_equal)
+isl::id basic_map::domain_tuple_id() const
 {
-  auto res = isl_basic_map_equal(space.release(), n_equal);
-  return manage(res);
+  return isl::map(*this).domain_tuple_id();
+}
+
+isl::map basic_map::eq_at(const isl::multi_pw_aff &mpa) const
+{
+  return isl::map(*this).eq_at(mpa);
+}
+
+isl::union_map basic_map::eq_at(const isl::multi_union_pw_aff &mupa) const
+{
+  return isl::map(*this).eq_at(mupa);
 }
 
-isl::mat basic_map::equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const
+isl::basic_map basic_map::equal(isl::space space, unsigned int n_equal)
 {
-  auto res = isl_basic_map_equalities_matrix(get(), static_cast<enum isl_dim_type>(c1), static_cast<enum isl_dim_type>(c2), static_cast<enum isl_dim_type>(c3), static_cast<enum isl_dim_type>(c4), static_cast<enum isl_dim_type>(c5));
+  auto res = isl_basic_map_equal(space.release(), n_equal);
   return manage(res);
 }
 
 isl::basic_map basic_map::equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 {
   auto res = isl_basic_map_equate(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
   return manage(res);
 }
 
-int basic_map::find_dim_by_name(isl::dim type, const std::string &name) const
+boolean basic_map::every_map(const std::function<boolean(isl::map)> &test) const
 {
-  auto res = isl_basic_map_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return isl::map(*this).every_map(test);
+}
+
+isl::map basic_map::extract_map(const isl::space &space) const
+{
+  return isl::map(*this).extract_map(space);
+}
+
+isl::map basic_map::factor_domain() const
+{
+  return isl::map(*this).factor_domain();
+}
+
+isl::map basic_map::factor_range() const
+{
+  return isl::map(*this).factor_range();
 }
 
 isl::basic_map basic_map::fix_si(isl::dim type, unsigned int pos, int value) const
 {
   auto res = isl_basic_map_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
   return manage(res);
 }
 
 isl::basic_map basic_map::fix_val(isl::dim type, unsigned int pos, isl::val v) const
 {
   auto res = isl_basic_map_fix_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
   return manage(res);
 }
 
-isl::basic_map basic_map::flat_product(isl::basic_map bmap2) const
+isl::basic_map basic_map::fix_val(isl::dim type, unsigned int pos, long v) const
 {
-  auto res = isl_basic_map_flat_product(copy(), bmap2.release());
-  return manage(res);
+  return this->fix_val(type, pos, isl::val(ctx(), v));
 }
 
-isl::basic_map basic_map::flat_range_product(isl::basic_map bmap2) const
+isl::union_map basic_map::fixed_power(const isl::val &exp) const
 {
-  auto res = isl_basic_map_flat_range_product(copy(), bmap2.release());
-  return manage(res);
+  return isl::map(*this).fixed_power(exp);
+}
+
+isl::union_map basic_map::fixed_power(long exp) const
+{
+  return this->fixed_power(isl::val(ctx(), exp));
+}
+
+isl::map basic_map::flat_range_product(const isl::map &map2) const
+{
+  return isl::map(*this).flat_range_product(map2);
+}
+
+isl::union_map basic_map::flat_range_product(const isl::union_map &umap2) const
+{
+  return isl::map(*this).flat_range_product(umap2);
 }
 
 isl::basic_map basic_map::flatten() const
 {
   auto res = isl_basic_map_flatten(copy());
   return manage(res);
 }
 
 isl::basic_map basic_map::flatten_domain() const
 {
   auto res = isl_basic_map_flatten_domain(copy());
   return manage(res);
 }
 
 isl::basic_map basic_map::flatten_range() const
 {
   auto res = isl_basic_map_flatten_range(copy());
   return manage(res);
 }
 
-stat basic_map::foreach_constraint(const std::function<stat(constraint)> &fn) const
+isl::map basic_map::floordiv_val(const isl::val &d) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_basic_map_foreach_constraint(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return isl::map(*this).floordiv_val(d);
 }
 
-isl::basic_map basic_map::from_aff(isl::aff aff)
+isl::map basic_map::floordiv_val(long d) const
 {
-  auto res = isl_basic_map_from_aff(aff.release());
-  return manage(res);
+  return this->floordiv_val(isl::val(ctx(), d));
 }
 
-isl::basic_map basic_map::from_aff_list(isl::space domain_space, isl::aff_list list)
+stat basic_map::foreach_basic_map(const std::function<stat(isl::basic_map)> &fn) const
 {
-  auto res = isl_basic_map_from_aff_list(domain_space.release(), list.release());
-  return manage(res);
+  return isl::map(*this).foreach_basic_map(fn);
 }
 
-isl::basic_map basic_map::from_constraint(isl::constraint constraint)
+stat basic_map::foreach_map(const std::function<stat(isl::map)> &fn) const
 {
-  auto res = isl_basic_map_from_constraint(constraint.release());
-  return manage(res);
+  return isl::map(*this).foreach_map(fn);
 }
 
-isl::basic_map basic_map::from_domain(isl::basic_set bset)
+isl::basic_map basic_map::from_aff(isl::aff aff)
 {
-  auto res = isl_basic_map_from_domain(bset.release());
+  auto res = isl_basic_map_from_aff(aff.release());
   return manage(res);
 }
 
 isl::basic_map basic_map::from_domain_and_range(isl::basic_set domain, isl::basic_set range)
 {
   auto res = isl_basic_map_from_domain_and_range(domain.release(), range.release());
   return manage(res);
 }
 
-isl::basic_map basic_map::from_multi_aff(isl::multi_aff maff)
+isl::basic_map basic_map::gist(isl::basic_map context) const
 {
-  auto res = isl_basic_map_from_multi_aff(maff.release());
+  auto res = isl_basic_map_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::basic_map basic_map::from_qpolynomial(isl::qpolynomial qp)
+isl::map basic_map::gist(const isl::map &context) const
 {
-  auto res = isl_basic_map_from_qpolynomial(qp.release());
-  return manage(res);
+  return isl::map(*this).gist(context);
 }
 
-isl::basic_map basic_map::from_range(isl::basic_set bset)
+isl::union_map basic_map::gist(const isl::union_map &context) const
 {
-  auto res = isl_basic_map_from_range(bset.release());
-  return manage(res);
+  return isl::map(*this).gist(context);
 }
 
-isl::constraint_list basic_map::get_constraint_list() const
+isl::map basic_map::gist_domain(const isl::set &context) const
 {
-  auto res = isl_basic_map_get_constraint_list(get());
-  return manage(res);
+  return isl::map(*this).gist_domain(context);
 }
 
-std::string basic_map::get_dim_name(isl::dim type, unsigned int pos) const
+isl::union_map basic_map::gist_domain(const isl::union_set &uset) const
 {
-  auto res = isl_basic_map_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return isl::map(*this).gist_domain(uset);
 }
 
-isl::aff basic_map::get_div(int pos) const
+isl::map basic_map::gist_params(const isl::set &context) const
 {
-  auto res = isl_basic_map_get_div(get(), pos);
-  return manage(res);
+  return isl::map(*this).gist_params(context);
 }
 
-isl::local_space basic_map::get_local_space() const
+isl::union_map basic_map::gist_range(const isl::union_set &uset) const
 {
-  auto res = isl_basic_map_get_local_space(get());
-  return manage(res);
+  return isl::map(*this).gist_range(uset);
 }
 
-isl::space basic_map::get_space() const
+boolean basic_map::has_domain_tuple_id() const
 {
-  auto res = isl_basic_map_get_space(get());
-  return manage(res);
+  return isl::map(*this).has_domain_tuple_id();
 }
 
-std::string basic_map::get_tuple_name(isl::dim type) const
+boolean basic_map::has_equal_space(const isl::map &map2) const
 {
-  auto res = isl_basic_map_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
+  return isl::map(*this).has_equal_space(map2);
 }
 
-isl::basic_map basic_map::gist(isl::basic_map context) const
+boolean basic_map::has_range_tuple_id() const
 {
-  auto res = isl_basic_map_gist(copy(), context.release());
-  return manage(res);
+  return isl::map(*this).has_range_tuple_id();
 }
 
-isl::basic_map basic_map::gist_domain(isl::basic_set context) const
+boolean basic_map::has_tuple_id(isl::dim type) const
 {
-  auto res = isl_basic_map_gist_domain(copy(), context.release());
-  return manage(res);
+  return isl::map(*this).has_tuple_id(type);
 }
 
-boolean basic_map::has_dim_id(isl::dim type, unsigned int pos) const
+boolean basic_map::has_tuple_name(isl::dim type) const
 {
-  auto res = isl_basic_map_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::map(*this).has_tuple_name(type);
 }
 
-isl::basic_map basic_map::identity(isl::space space)
+isl::basic_map basic_map::intersect(isl::basic_map bmap2) const
 {
-  auto res = isl_basic_map_identity(space.release());
+  auto res = isl_basic_map_intersect(copy(), bmap2.release());
   return manage(res);
 }
 
-boolean basic_map::image_is_bounded() const
+isl::map basic_map::intersect(const isl::map &map2) const
 {
-  auto res = isl_basic_map_image_is_bounded(get());
-  return manage(res);
+  return isl::map(*this).intersect(map2);
 }
 
-isl::mat basic_map::inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4, isl::dim c5) const
+isl::union_map basic_map::intersect(const isl::union_map &umap2) const
 {
-  auto res = isl_basic_map_inequalities_matrix(get(), static_cast<enum isl_dim_type>(c1), static_cast<enum isl_dim_type>(c2), static_cast<enum isl_dim_type>(c3), static_cast<enum isl_dim_type>(c4), static_cast<enum isl_dim_type>(c5));
-  return manage(res);
+  return isl::map(*this).intersect(umap2);
 }
 
-isl::basic_map basic_map::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
+isl::basic_map basic_map::intersect_domain(isl::basic_set bset) const
 {
-  auto res = isl_basic_map_insert_dims(copy(), static_cast<enum isl_dim_type>(type), pos, n);
+  auto res = isl_basic_map_intersect_domain(copy(), bset.release());
   return manage(res);
 }
 
-isl::basic_map basic_map::intersect(isl::basic_map bmap2) const
+isl::map basic_map::intersect_domain(const isl::set &set) const
 {
-  auto res = isl_basic_map_intersect(copy(), bmap2.release());
-  return manage(res);
+  return isl::map(*this).intersect_domain(set);
 }
 
-isl::basic_map basic_map::intersect_domain(isl::basic_set bset) const
+isl::union_map basic_map::intersect_domain(const isl::space &space) const
 {
-  auto res = isl_basic_map_intersect_domain(copy(), bset.release());
-  return manage(res);
+  return isl::map(*this).intersect_domain(space);
+}
+
+isl::union_map basic_map::intersect_domain(const isl::union_set &uset) const
+{
+  return isl::map(*this).intersect_domain(uset);
+}
+
+isl::basic_map basic_map::intersect_domain(const isl::point &bset) const
+{
+  return this->intersect_domain(isl::basic_set(bset));
+}
+
+isl::map basic_map::intersect_domain_factor_domain(const isl::map &factor) const
+{
+  return isl::map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::union_map basic_map::intersect_domain_factor_domain(const isl::union_map &factor) const
+{
+  return isl::map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::map basic_map::intersect_domain_factor_range(const isl::map &factor) const
+{
+  return isl::map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::union_map basic_map::intersect_domain_factor_range(const isl::union_map &factor) const
+{
+  return isl::map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::map basic_map::intersect_params(const isl::set &params) const
+{
+  return isl::map(*this).intersect_params(params);
 }
 
 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::map basic_map::intersect_range(const isl::set &set) const
+{
+  return isl::map(*this).intersect_range(set);
+}
+
+isl::union_map basic_map::intersect_range(const isl::space &space) const
+{
+  return isl::map(*this).intersect_range(space);
+}
+
+isl::union_map basic_map::intersect_range(const isl::union_set &uset) const
+{
+  return isl::map(*this).intersect_range(uset);
+}
+
+isl::basic_map basic_map::intersect_range(const isl::point &bset) const
+{
+  return this->intersect_range(isl::basic_set(bset));
+}
+
+isl::map basic_map::intersect_range_factor_domain(const isl::map &factor) const
+{
+  return isl::map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::union_map basic_map::intersect_range_factor_domain(const isl::union_map &factor) const
+{
+  return isl::map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::map basic_map::intersect_range_factor_range(const isl::map &factor) const
+{
+  return isl::map(*this).intersect_range_factor_range(factor);
+}
+
+isl::union_map basic_map::intersect_range_factor_range(const isl::union_map &factor) const
+{
+  return isl::map(*this).intersect_range_factor_range(factor);
+}
+
 boolean basic_map::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_map_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).involves_dims(type, first, n);
 }
 
-boolean basic_map::is_disjoint(const isl::basic_map &bmap2) const
+boolean basic_map::is_bijective() const
 {
-  auto res = isl_basic_map_is_disjoint(get(), bmap2.get());
-  return manage(res);
+  return isl::map(*this).is_bijective();
+}
+
+boolean basic_map::is_disjoint(const isl::map &map2) const
+{
+  return isl::map(*this).is_disjoint(map2);
+}
+
+boolean basic_map::is_disjoint(const isl::union_map &umap2) const
+{
+  return isl::map(*this).is_disjoint(umap2);
 }
 
 boolean basic_map::is_empty() const
 {
   auto res = isl_basic_map_is_empty(get());
   return manage(res);
 }
 
 boolean basic_map::is_equal(const isl::basic_map &bmap2) const
 {
   auto res = isl_basic_map_is_equal(get(), bmap2.get());
   return manage(res);
 }
 
-boolean basic_map::is_rational() const
+boolean basic_map::is_equal(const isl::map &map2) const
 {
-  auto res = isl_basic_map_is_rational(get());
-  return manage(res);
+  return isl::map(*this).is_equal(map2);
+}
+
+boolean basic_map::is_equal(const isl::union_map &umap2) const
+{
+  return isl::map(*this).is_equal(umap2);
+}
+
+boolean basic_map::is_injective() const
+{
+  return isl::map(*this).is_injective();
 }
 
 boolean basic_map::is_single_valued() const
 {
-  auto res = isl_basic_map_is_single_valued(get());
-  return manage(res);
+  return isl::map(*this).is_single_valued();
 }
 
-boolean basic_map::is_strict_subset(const isl::basic_map &bmap2) const
+boolean basic_map::is_strict_subset(const isl::map &map2) const
 {
-  auto res = isl_basic_map_is_strict_subset(get(), bmap2.get());
-  return manage(res);
+  return isl::map(*this).is_strict_subset(map2);
+}
+
+boolean basic_map::is_strict_subset(const isl::union_map &umap2) const
+{
+  return isl::map(*this).is_strict_subset(umap2);
 }
 
 boolean basic_map::is_subset(const isl::basic_map &bmap2) const
 {
   auto res = isl_basic_map_is_subset(get(), bmap2.get());
   return manage(res);
 }
 
-boolean basic_map::is_universe() const
+boolean basic_map::is_subset(const isl::map &map2) const
 {
-  auto res = isl_basic_map_is_universe(get());
-  return manage(res);
+  return isl::map(*this).is_subset(map2);
 }
 
-isl::basic_map basic_map::less_at(isl::space space, unsigned int pos)
+boolean basic_map::is_subset(const isl::union_map &umap2) const
 {
-  auto res = isl_basic_map_less_at(space.release(), pos);
-  return manage(res);
+  return isl::map(*this).is_subset(umap2);
+}
+
+boolean basic_map::isa_map() const
+{
+  return isl::map(*this).isa_map();
+}
+
+isl::map basic_map::lex_ge_at(const isl::multi_pw_aff &mpa) const
+{
+  return isl::map(*this).lex_ge_at(mpa);
+}
+
+isl::map basic_map::lex_gt_at(const isl::multi_pw_aff &mpa) const
+{
+  return isl::map(*this).lex_gt_at(mpa);
+}
+
+isl::map basic_map::lex_le_at(const isl::multi_pw_aff &mpa) const
+{
+  return isl::map(*this).lex_le_at(mpa);
+}
+
+isl::map basic_map::lex_lt_at(const isl::multi_pw_aff &mpa) const
+{
+  return isl::map(*this).lex_lt_at(mpa);
 }
 
 isl::map basic_map::lexmax() const
 {
   auto res = isl_basic_map_lexmax(copy());
   return manage(res);
 }
 
+isl::pw_multi_aff basic_map::lexmax_pw_multi_aff() const
+{
+  return isl::map(*this).lexmax_pw_multi_aff();
+}
+
 isl::map basic_map::lexmin() const
 {
   auto res = isl_basic_map_lexmin(copy());
   return manage(res);
 }
 
 isl::pw_multi_aff basic_map::lexmin_pw_multi_aff() const
 {
-  auto res = isl_basic_map_lexmin_pw_multi_aff(copy());
-  return manage(res);
+  return isl::map(*this).lexmin_pw_multi_aff();
 }
 
-isl::basic_map basic_map::lower_bound_si(isl::dim type, unsigned int pos, int value) const
+isl::map basic_map::lower_bound(const isl::multi_pw_aff &lower) const
 {
-  auto res = isl_basic_map_lower_bound_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
-  return manage(res);
+  return isl::map(*this).lower_bound(lower);
 }
 
-isl::basic_map basic_map::more_at(isl::space space, unsigned int pos)
+isl::map basic_map::lower_bound_si(isl::dim type, unsigned int pos, int value) const
 {
-  auto res = isl_basic_map_more_at(space.release(), pos);
-  return manage(res);
+  return isl::map(*this).lower_bound_si(type, pos, value);
 }
 
-isl::basic_map basic_map::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::map_list basic_map::map_list() const
 {
-  auto res = isl_basic_map_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);
+  return isl::map(*this).map_list();
 }
 
-isl_size basic_map::n_constraint() const
+isl::multi_pw_aff basic_map::max_multi_pw_aff() const
 {
-  auto res = isl_basic_map_n_constraint(get());
-  return res;
+  return isl::map(*this).max_multi_pw_aff();
 }
 
-isl::basic_map basic_map::nat_universe(isl::space space)
+isl::multi_pw_aff basic_map::min_multi_pw_aff() const
 {
-  auto res = isl_basic_map_nat_universe(space.release());
-  return manage(res);
+  return isl::map(*this).min_multi_pw_aff();
 }
 
-isl::basic_map basic_map::neg() const
+isl::map basic_map::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_basic_map_neg(copy());
-  return manage(res);
+  return isl::map(*this).move_dims(dst_type, dst_pos, src_type, src_pos, n);
 }
 
-isl::basic_map basic_map::order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+class size basic_map::n_basic_map() const
 {
-  auto res = isl_basic_map_order_ge(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
-  return manage(res);
+  return isl::map(*this).n_basic_map();
 }
 
-isl::basic_map basic_map::order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::map basic_map::order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 {
-  auto res = isl_basic_map_order_gt(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
-  return manage(res);
+  return isl::map(*this).order_lt(type1, pos1, type2, pos2);
+}
+
+isl::set basic_map::params() const
+{
+  return isl::map(*this).params();
 }
 
 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);
 }
 
-boolean basic_map::plain_is_empty() const
+isl::basic_map basic_map::polyhedral_hull() const
 {
-  auto res = isl_basic_map_plain_is_empty(get());
-  return manage(res);
+  return isl::map(*this).polyhedral_hull();
 }
 
-boolean basic_map::plain_is_universe() const
+isl::map basic_map::preimage_domain(const isl::multi_aff &ma) const
 {
-  auto res = isl_basic_map_plain_is_universe(get());
-  return manage(res);
+  return isl::map(*this).preimage_domain(ma);
 }
 
-isl::basic_map basic_map::preimage_domain_multi_aff(isl::multi_aff ma) const
+isl::map basic_map::preimage_domain(const isl::multi_pw_aff &mpa) const
 {
-  auto res = isl_basic_map_preimage_domain_multi_aff(copy(), ma.release());
-  return manage(res);
+  return isl::map(*this).preimage_domain(mpa);
 }
 
-isl::basic_map basic_map::preimage_range_multi_aff(isl::multi_aff ma) const
+isl::map basic_map::preimage_domain(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_basic_map_preimage_range_multi_aff(copy(), ma.release());
-  return manage(res);
+  return isl::map(*this).preimage_domain(pma);
 }
 
-isl::basic_map basic_map::product(isl::basic_map bmap2) const
+isl::union_map basic_map::preimage_domain(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_basic_map_product(copy(), bmap2.release());
-  return manage(res);
+  return isl::map(*this).preimage_domain(upma);
 }
 
-isl::basic_map basic_map::project_out(isl::dim type, unsigned int first, unsigned int n) const
+isl::map basic_map::preimage_range(const isl::multi_aff &ma) const
 {
-  auto res = isl_basic_map_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).preimage_range(ma);
 }
 
-isl::basic_set basic_map::range() const
+isl::map basic_map::preimage_range(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_basic_map_range(copy());
-  return manage(res);
+  return isl::map(*this).preimage_range(pma);
 }
 
-isl::basic_map basic_map::range_map() const
+isl::union_map basic_map::preimage_range(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_basic_map_range_map(copy());
-  return manage(res);
+  return isl::map(*this).preimage_range(upma);
 }
 
-isl::basic_map basic_map::range_product(isl::basic_map bmap2) const
+isl::map basic_map::product(const isl::map &map2) const
 {
-  auto res = isl_basic_map_range_product(copy(), bmap2.release());
-  return manage(res);
+  return isl::map(*this).product(map2);
 }
 
-isl::basic_map basic_map::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_map basic_map::product(const isl::union_map &umap2) const
 {
-  auto res = isl_basic_map_remove_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).product(umap2);
 }
 
-isl::basic_map basic_map::remove_divs() const
+isl::map basic_map::project_out(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_map_remove_divs(copy());
-  return manage(res);
+  return isl::map(*this).project_out(type, first, n);
 }
 
-isl::basic_map basic_map::remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::map basic_map::project_out_all_params() const
 {
-  auto res = isl_basic_map_remove_divs_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::map(*this).project_out_all_params();
 }
 
-isl::basic_map basic_map::remove_redundancies() const
+isl::set basic_map::range() const
 {
-  auto res = isl_basic_map_remove_redundancies(copy());
-  return manage(res);
+  return isl::map(*this).range();
+}
+
+isl::map basic_map::range_factor_domain() const
+{
+  return isl::map(*this).range_factor_domain();
+}
+
+isl::map basic_map::range_factor_range() const
+{
+  return isl::map(*this).range_factor_range();
+}
+
+isl::fixed_box basic_map::range_lattice_tile() const
+{
+  return isl::map(*this).range_lattice_tile();
+}
+
+isl::map basic_map::range_map() const
+{
+  return isl::map(*this).range_map();
+}
+
+isl::map basic_map::range_product(const isl::map &map2) const
+{
+  return isl::map(*this).range_product(map2);
+}
+
+isl::union_map basic_map::range_product(const isl::union_map &umap2) const
+{
+  return isl::map(*this).range_product(umap2);
+}
+
+isl::map basic_map::range_reverse() const
+{
+  return isl::map(*this).range_reverse();
+}
+
+isl::fixed_box basic_map::range_simple_fixed_box_hull() const
+{
+  return isl::map(*this).range_simple_fixed_box_hull();
+}
+
+class size basic_map::range_tuple_dim() const
+{
+  return isl::map(*this).range_tuple_dim();
+}
+
+isl::id basic_map::range_tuple_id() const
+{
+  return isl::map(*this).range_tuple_id();
 }
 
 isl::basic_map basic_map::reverse() const
 {
   auto res = isl_basic_map_reverse(copy());
   return manage(res);
 }
 
 isl::basic_map basic_map::sample() const
 {
   auto res = isl_basic_map_sample(copy());
   return manage(res);
 }
 
-isl::basic_map basic_map::set_tuple_id(isl::dim type, isl::id id) const
+isl::map basic_map::set_domain_tuple(const isl::id &id) const
 {
-  auto res = isl_basic_map_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
-  return manage(res);
+  return isl::map(*this).set_domain_tuple(id);
 }
 
-isl::basic_map basic_map::set_tuple_name(isl::dim type, const std::string &s) const
+isl::map basic_map::set_domain_tuple(const std::string &id) const
 {
-  auto res = isl_basic_map_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
-  return manage(res);
+  return this->set_domain_tuple(isl::id(ctx(), id));
 }
 
-isl::basic_map basic_map::sum(isl::basic_map bmap2) const
+isl::map basic_map::set_range_tuple(const isl::id &id) const
 {
-  auto res = isl_basic_map_sum(copy(), bmap2.release());
-  return manage(res);
+  return isl::map(*this).set_range_tuple(id);
+}
+
+isl::map basic_map::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::map basic_map::set_tuple_id(isl::dim type, const isl::id &id) const
+{
+  return isl::map(*this).set_tuple_id(type, id);
+}
+
+isl::map basic_map::set_tuple_id(isl::dim type, const std::string &id) const
+{
+  return this->set_tuple_id(type, isl::id(ctx(), id));
+}
+
+isl::space basic_map::space() const
+{
+  return isl::map(*this).space();
+}
+
+isl::map basic_map::subtract(const isl::map &map2) const
+{
+  return isl::map(*this).subtract(map2);
+}
+
+isl::union_map basic_map::subtract(const isl::union_map &umap2) const
+{
+  return isl::map(*this).subtract(umap2);
+}
+
+isl::union_map basic_map::subtract_domain(const isl::union_set &dom) const
+{
+  return isl::map(*this).subtract_domain(dom);
+}
+
+isl::union_map basic_map::subtract_range(const isl::union_set &dom) const
+{
+  return isl::map(*this).subtract_range(dom);
 }
 
-isl::basic_map basic_map::uncurry() const
+isl::map basic_map::sum(const isl::map &map2) const
 {
-  auto res = isl_basic_map_uncurry(copy());
+  return isl::map(*this).sum(map2);
+}
+
+isl::basic_map_list basic_map::to_list() const
+{
+  auto res = isl_basic_map_to_list(copy());
   return manage(res);
 }
 
+isl::union_map basic_map::to_union_map() const
+{
+  return isl::map(*this).to_union_map();
+}
+
+isl::id basic_map::tuple_id(isl::dim type) const
+{
+  return isl::map(*this).tuple_id(type);
+}
+
+isl::map basic_map::uncurry() const
+{
+  return isl::map(*this).uncurry();
+}
+
 isl::map basic_map::unite(isl::basic_map bmap2) const
 {
   auto res = isl_basic_map_union(copy(), bmap2.release());
   return manage(res);
 }
 
+isl::map basic_map::unite(const isl::map &map2) const
+{
+  return isl::map(*this).unite(map2);
+}
+
+isl::union_map basic_map::unite(const isl::union_map &umap2) const
+{
+  return isl::map(*this).unite(umap2);
+}
+
 isl::basic_map basic_map::universe(isl::space space)
 {
   auto res = isl_basic_map_universe(space.release());
   return manage(res);
 }
 
-isl::basic_map basic_map::upper_bound_si(isl::dim type, unsigned int pos, int value) const
+isl::basic_map basic_map::unshifted_simple_hull() const
 {
-  auto res = isl_basic_map_upper_bound_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
-  return manage(res);
+  return isl::map(*this).unshifted_simple_hull();
 }
 
-isl::basic_set basic_map::wrap() const
+isl::map basic_map::upper_bound(const isl::multi_pw_aff &upper) const
 {
-  auto res = isl_basic_map_wrap(copy());
-  return manage(res);
+  return isl::map(*this).upper_bound(upper);
 }
 
-isl::basic_map basic_map::zip() const
+isl::map basic_map::upper_bound_si(isl::dim type, unsigned int pos, int value) const
 {
-  auto res = isl_basic_map_zip(copy());
-  return manage(res);
+  return isl::map(*this).upper_bound_si(type, pos, value);
+}
+
+isl::set basic_map::wrap() const
+{
+  return isl::map(*this).wrap();
+}
+
+isl::map basic_map::zip() const
+{
+  return isl::map(*this).zip();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const basic_map &obj)
+{
+  char *str = isl_basic_map_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::basic_map_list
 basic_map_list manage(__isl_take isl_basic_map_list *ptr) {
   return basic_map_list(ptr);
 }
 basic_map_list manage_copy(__isl_keep isl_basic_map_list *ptr) {
   ptr = isl_basic_map_list_copy(ptr);
   return basic_map_list(ptr);
 }
 
 basic_map_list::basic_map_list()
     : ptr(nullptr) {}
 
 basic_map_list::basic_map_list(const basic_map_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 basic_map_list::basic_map_list(__isl_take isl_basic_map_list *ptr)
     : ptr(ptr) {}
 
+basic_map_list::basic_map_list(isl::ctx ctx, int n)
+{
+  auto res = isl_basic_map_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+basic_map_list::basic_map_list(isl::basic_map el)
+{
+  auto res = isl_basic_map_list_from_basic_map(el.release());
+  ptr = res;
+}
 
 basic_map_list &basic_map_list::operator=(basic_map_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 basic_map_list::~basic_map_list() {
   if (ptr)
__isl_give isl_basic_map_list *basic_map_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_map_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx basic_map_list::ctx() const {
   return isl::ctx(isl_basic_map_list_get_ctx(ptr));
 }
 
-void basic_map_list::dump() const {
-  isl_basic_map_list_dump(get());
-}
-
-
 isl::basic_map_list basic_map_list::add(isl::basic_map el) const
 {
   auto res = isl_basic_map_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::basic_map_list basic_map_list::alloc(isl::ctx ctx, int n)
+isl::basic_map basic_map_list::at(int index) const
 {
-  auto res = isl_basic_map_list_alloc(ctx.release(), n);
+  auto res = isl_basic_map_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::basic_map basic_map_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::basic_map_list basic_map_list::clear() const
 {
   auto res = isl_basic_map_list_clear(copy());
   return manage(res);
 }
 
 isl::basic_map_list basic_map_list::concat(isl::basic_map_list list2) const
 {
   auto res = isl_basic_map_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::basic_map_list basic_map_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_basic_map_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat basic_map_list::foreach(const std::function<stat(basic_map)> &fn) const
+stat basic_map_list::foreach(const std::function<stat(isl::basic_map)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(basic_map)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_basic_map_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::basic_map_list basic_map_list::from_basic_map(isl::basic_map el)
-{
-  auto res = isl_basic_map_list_from_basic_map(el.release());
-  return manage(res);
-}
-
-isl::basic_map basic_map_list::get_at(int index) const
-{
-  auto res = isl_basic_map_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::basic_map basic_map_list::get_basic_map(int index) const
-{
-  auto res = isl_basic_map_list_get_basic_map(get(), index);
-  return manage(res);
-}
-
 isl::basic_map_list basic_map_list::insert(unsigned int pos, isl::basic_map el) const
 {
   auto res = isl_basic_map_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size basic_map_list::n_basic_map() const
-{
-  auto res = isl_basic_map_list_n_basic_map(get());
-  return res;
-}
-
-isl::basic_map_list basic_map_list::reverse() const
-{
-  auto res = isl_basic_map_list_reverse(copy());
-  return manage(res);
-}
-
-isl::basic_map_list basic_map_list::set_basic_map(int index, isl::basic_map el) const
-{
-  auto res = isl_basic_map_list_set_basic_map(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size basic_map_list::size() const
+class size basic_map_list::size() const
 {
   auto res = isl_basic_map_list_size(get());
-  return res;
+  return manage(res);
 }
 
-isl::basic_map_list basic_map_list::swap(unsigned int pos1, unsigned int pos2) const
+inline std::ostream &operator<<(std::ostream &os, const basic_map_list &obj)
 {
-  auto res = isl_basic_map_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_basic_map_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::basic_set
 basic_set manage(__isl_take isl_basic_set *ptr) {
   return basic_set(ptr);
 }
 basic_set manage_copy(__isl_keep isl_basic_set *ptr) {
   ptr = isl_basic_set_copy(ptr);
   return basic_set(ptr);
 }
 
 basic_set::basic_set()
     : ptr(nullptr) {}
 
 basic_set::basic_set(const basic_set &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 basic_set::basic_set(__isl_take isl_basic_set *ptr)
     : ptr(ptr) {}
 
 basic_set::basic_set(isl::point pnt)
 {
   auto res = isl_basic_set_from_point(pnt.release());
   ptr = res;
 }
+
 basic_set::basic_set(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_basic_set_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 basic_set &basic_set::operator=(basic_set obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_basic_set *basic_set::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_set::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx basic_set::ctx() const {
   return isl::ctx(isl_basic_set_get_ctx(ptr));
 }
 
-void basic_set::dump() const {
-  isl_basic_set_dump(get());
+isl::set basic_set::add_constraint(const isl::constraint &constraint) const
+{
+  return isl::set(*this).add_constraint(constraint);
 }
 
+isl::set basic_set::add_dims(isl::dim type, unsigned int n) const
+{
+  return isl::set(*this).add_dims(type, n);
+}
 
 isl::basic_set basic_set::affine_hull() const
 {
   auto res = isl_basic_set_affine_hull(copy());
   return manage(res);
 }
 
-isl::basic_set basic_set::align_params(isl::space model) const
+isl::set basic_set::align_params(const isl::space &model) const
 {
-  auto res = isl_basic_set_align_params(copy(), model.release());
-  return manage(res);
+  return isl::set(*this).align_params(model);
 }
 
 isl::basic_set basic_set::apply(isl::basic_map bmap) const
 {
   auto res = isl_basic_set_apply(copy(), bmap.release());
   return manage(res);
 }
 
-isl::basic_set basic_set::box_from_points(isl::point pnt1, isl::point pnt2)
+isl::set basic_set::apply(const isl::map &map) const
 {
-  auto res = isl_basic_set_box_from_points(pnt1.release(), pnt2.release());
-  return manage(res);
+  return isl::set(*this).apply(map);
 }
 
-isl::basic_set basic_set::coefficients() const
+isl::union_set basic_set::apply(const isl::union_map &umap) const
 {
-  auto res = isl_basic_set_coefficients(copy());
-  return manage(res);
+  return isl::set(*this).apply(umap);
 }
 
-isl::basic_set basic_set::detect_equalities() const
+isl::pw_multi_aff basic_set::as_pw_multi_aff() const
 {
-  auto res = isl_basic_set_detect_equalities(copy());
-  return manage(res);
+  return isl::set(*this).as_pw_multi_aff();
 }
 
-isl_size basic_set::dim(isl::dim type) const
+isl::set basic_set::as_set() const
 {
-  auto res = isl_basic_set_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::set(*this).as_set();
 }
 
-isl::val basic_set::dim_max_val(int pos) const
+isl::basic_set_list basic_set::basic_set_list() const
 {
-  auto res = isl_basic_set_dim_max_val(copy(), pos);
-  return manage(res);
+  return isl::set(*this).basic_set_list();
 }
 
-isl::basic_set basic_set::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::set basic_set::bind(const isl::multi_id &tuple) const
 {
-  auto res = isl_basic_set_drop_constraints_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).bind(tuple);
 }
 
-isl::basic_set basic_set::drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::set basic_set::coalesce() const
 {
-  auto res = isl_basic_set_drop_constraints_not_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).coalesce();
 }
 
-isl::basic_set basic_set::drop_unused_params() const
+isl::set basic_set::complement() const
 {
-  auto res = isl_basic_set_drop_unused_params(copy());
-  return manage(res);
+  return isl::set(*this).complement();
 }
 
-isl::basic_set basic_set::eliminate(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_set basic_set::compute_divs() const
 {
-  auto res = isl_basic_set_eliminate(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).compute_divs();
 }
 
-isl::basic_set basic_set::empty(isl::space space)
+boolean basic_set::contains(const isl::space &space) const
 {
-  auto res = isl_basic_set_empty(space.release());
-  return manage(res);
+  return isl::set(*this).contains(space);
 }
 
-isl::mat basic_set::equalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const
+isl::basic_set basic_set::convex_hull() const
 {
-  auto res = isl_basic_set_equalities_matrix(get(), static_cast<enum isl_dim_type>(c1), static_cast<enum isl_dim_type>(c2), static_cast<enum isl_dim_type>(c3), static_cast<enum isl_dim_type>(c4));
-  return manage(res);
+  return isl::set(*this).convex_hull();
 }
 
-isl::basic_set basic_set::fix_si(isl::dim type, unsigned int pos, int value) const
+isl::basic_set basic_set::detect_equalities() const
 {
-  auto res = isl_basic_set_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
+  auto res = isl_basic_set_detect_equalities(copy());
   return manage(res);
 }
 
-isl::basic_set basic_set::fix_val(isl::dim type, unsigned int pos, isl::val v) const
+class size basic_set::dim(isl::dim type) const
 {
-  auto res = isl_basic_set_fix_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
+  auto res = isl_basic_set_dim(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::basic_set basic_set::flat_product(isl::basic_set bset2) const
+boolean basic_set::dim_has_any_lower_bound(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_basic_set_flat_product(copy(), bset2.release());
-  return manage(res);
+  return isl::set(*this).dim_has_any_lower_bound(type, pos);
 }
 
-isl::basic_set basic_set::flatten() const
+isl::id basic_set::dim_id(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_basic_set_flatten(copy());
-  return manage(res);
+  return isl::set(*this).dim_id(type, pos);
 }
 
-stat basic_set::foreach_bound_pair(isl::dim type, unsigned int pos, const std::function<stat(constraint, constraint, basic_set)> &fn) const
+isl::pw_aff basic_set::dim_max(int pos) const
 {
-  struct fn_data {
-    const std::function<stat(constraint, constraint, 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)(manage(arg_0), manage(arg_1), manage(arg_2));
-    return ret.release();
-  };
-  auto res = isl_basic_set_foreach_bound_pair(get(), static_cast<enum isl_dim_type>(type), pos, fn_lambda, &fn_data);
-  return manage(res);
+  return isl::set(*this).dim_max(pos);
 }
 
-stat basic_set::foreach_constraint(const std::function<stat(constraint)> &fn) const
+isl::val basic_set::dim_max_val(int pos) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_basic_set_foreach_constraint(get(), fn_lambda, &fn_data);
+  auto res = isl_basic_set_dim_max_val(copy(), pos);
   return manage(res);
 }
 
-isl::basic_set basic_set::from_constraint(isl::constraint constraint)
+isl::pw_aff basic_set::dim_min(int pos) const
 {
-  auto res = isl_basic_set_from_constraint(constraint.release());
-  return manage(res);
+  return isl::set(*this).dim_min(pos);
 }
 
-isl::basic_set basic_set::from_multi_aff(isl::multi_aff ma)
+isl::val basic_set::dim_min_val(int pos) const
 {
-  auto res = isl_basic_set_from_multi_aff(ma.release());
-  return manage(res);
+  return isl::set(*this).dim_min_val(pos);
 }
 
-isl::basic_set basic_set::from_params() const
+std::string basic_set::dim_name(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_basic_set_from_params(copy());
-  return manage(res);
+  return isl::set(*this).dim_name(type, pos);
 }
 
-isl::constraint_list basic_set::get_constraint_list() const
+isl::aff basic_set::div(int pos) const
 {
-  auto res = isl_basic_set_get_constraint_list(get());
+  auto res = isl_basic_set_get_div(get(), pos);
   return manage(res);
 }
 
-isl::id basic_set::get_dim_id(isl::dim type, unsigned int pos) const
+isl::aff basic_set::get_div(int pos) const
 {
-  auto res = isl_basic_set_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return div(pos);
 }
 
-std::string basic_set::get_dim_name(isl::dim type, unsigned int pos) const
+isl::set basic_set::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_set_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return isl::set(*this).drop_constraints_involving_dims(type, first, n);
 }
 
-isl::aff basic_set::get_div(int pos) const
+isl::set basic_set::eliminate(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_set_get_div(get(), pos);
-  return manage(res);
+  return isl::set(*this).eliminate(type, first, n);
 }
 
-isl::local_space basic_set::get_local_space() const
+boolean basic_set::every_set(const std::function<boolean(isl::set)> &test) const
 {
-  auto res = isl_basic_set_get_local_space(get());
-  return manage(res);
+  return isl::set(*this).every_set(test);
 }
 
-isl::space basic_set::get_space() const
+isl::set basic_set::extract_set(const isl::space &space) const
 {
-  auto res = isl_basic_set_get_space(get());
-  return manage(res);
+  return isl::set(*this).extract_set(space);
 }
 
-std::string basic_set::get_tuple_name() const
+int basic_set::find_dim_by_id(isl::dim type, const isl::id &id) const
 {
-  auto res = isl_basic_set_get_tuple_name(get());
-  std::string tmp(res);
-  return tmp;
+  return isl::set(*this).find_dim_by_id(type, id);
 }
 
-isl::basic_set basic_set::gist(isl::basic_set context) const
+int basic_set::find_dim_by_id(isl::dim type, const std::string &id) const
 {
-  auto res = isl_basic_set_gist(copy(), context.release());
-  return manage(res);
+  return this->find_dim_by_id(type, isl::id(ctx(), id));
 }
 
-isl::mat basic_set::inequalities_matrix(isl::dim c1, isl::dim c2, isl::dim c3, isl::dim c4) const
+isl::basic_set basic_set::fix_si(isl::dim type, unsigned int pos, int value) const
 {
-  auto res = isl_basic_set_inequalities_matrix(get(), static_cast<enum isl_dim_type>(c1), static_cast<enum isl_dim_type>(c2), static_cast<enum isl_dim_type>(c3), static_cast<enum isl_dim_type>(c4));
+  auto res = isl_basic_set_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
   return manage(res);
 }
 
-isl::basic_set basic_set::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
+isl::basic_set basic_set::fix_val(isl::dim type, unsigned int pos, isl::val v) const
 {
-  auto res = isl_basic_set_insert_dims(copy(), static_cast<enum isl_dim_type>(type), pos, n);
+  auto res = isl_basic_set_fix_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
   return manage(res);
 }
 
-isl::basic_set basic_set::intersect(isl::basic_set bset2) const
+isl::basic_set basic_set::fix_val(isl::dim type, unsigned int pos, long v) const
 {
-  auto res = isl_basic_set_intersect(copy(), bset2.release());
-  return manage(res);
+  return this->fix_val(type, pos, isl::val(ctx(), v));
 }
 
-isl::basic_set basic_set::intersect_params(isl::basic_set bset2) const
+isl::basic_set basic_set::flatten() const
 {
-  auto res = isl_basic_set_intersect_params(copy(), bset2.release());
+  auto res = isl_basic_set_flatten(copy());
   return manage(res);
 }
 
-boolean basic_set::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+stat basic_set::foreach_basic_set(const std::function<stat(isl::basic_set)> &fn) const
 {
-  auto res = isl_basic_set_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).foreach_basic_set(fn);
 }
 
-boolean basic_set::is_bounded() const
+stat basic_set::foreach_point(const std::function<stat(isl::point)> &fn) const
 {
-  auto res = isl_basic_set_is_bounded(get());
-  return manage(res);
+  return isl::set(*this).foreach_point(fn);
 }
 
-boolean basic_set::is_disjoint(const isl::basic_set &bset2) const
+stat basic_set::foreach_set(const std::function<stat(isl::set)> &fn) const
 {
-  auto res = isl_basic_set_is_disjoint(get(), bset2.get());
-  return manage(res);
+  return isl::set(*this).foreach_set(fn);
 }
 
-boolean basic_set::is_empty() const
+isl::basic_set basic_set::gist(isl::basic_set context) const
 {
-  auto res = isl_basic_set_is_empty(get());
+  auto res = isl_basic_set_gist(copy(), context.release());
   return manage(res);
 }
 
-boolean basic_set::is_equal(const isl::basic_set &bset2) const
+isl::set basic_set::gist(const isl::set &context) const
 {
-  auto res = isl_basic_set_is_equal(get(), bset2.get());
-  return manage(res);
+  return isl::set(*this).gist(context);
 }
 
-int basic_set::is_rational() const
+isl::union_set basic_set::gist(const isl::union_set &context) const
 {
-  auto res = isl_basic_set_is_rational(get());
-  return res;
+  return isl::set(*this).gist(context);
 }
 
-boolean basic_set::is_subset(const isl::basic_set &bset2) const
+isl::basic_set basic_set::gist(const isl::point &context) const
 {
-  auto res = isl_basic_set_is_subset(get(), bset2.get());
-  return manage(res);
+  return this->gist(isl::basic_set(context));
 }
 
-boolean basic_set::is_universe() const
+isl::set basic_set::gist_params(const isl::set &context) const
 {
-  auto res = isl_basic_set_is_universe(get());
-  return manage(res);
+  return isl::set(*this).gist_params(context);
 }
 
-boolean basic_set::is_wrapping() const
+boolean basic_set::has_equal_space(const isl::set &set2) const
 {
-  auto res = isl_basic_set_is_wrapping(get());
-  return manage(res);
+  return isl::set(*this).has_equal_space(set2);
 }
 
-isl::set basic_set::lexmax() const
+isl::map basic_set::identity() const
 {
-  auto res = isl_basic_set_lexmax(copy());
-  return manage(res);
+  return isl::set(*this).identity();
 }
 
-isl::set basic_set::lexmin() const
+isl::union_pw_multi_aff basic_set::identity_union_pw_multi_aff() const
 {
-  auto res = isl_basic_set_lexmin(copy());
-  return manage(res);
+  return isl::set(*this).identity_union_pw_multi_aff();
 }
 
-isl::basic_set basic_set::lower_bound_val(isl::dim type, unsigned int pos, isl::val value) const
+isl::pw_aff basic_set::indicator_function() const
 {
-  auto res = isl_basic_set_lower_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
-  return manage(res);
+  return isl::set(*this).indicator_function();
 }
 
-isl::val basic_set::max_val(const isl::aff &obj) const
+isl::set basic_set::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
 {
-  auto res = isl_basic_set_max_val(get(), obj.get());
-  return manage(res);
+  return isl::set(*this).insert_dims(type, pos, n);
 }
 
-isl::basic_set basic_set::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::map basic_set::insert_domain(const isl::space &domain) const
 {
-  auto res = isl_basic_set_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);
+  return isl::set(*this).insert_domain(domain);
 }
 
-isl_size basic_set::n_constraint() const
+isl::basic_set basic_set::intersect(isl::basic_set bset2) const
 {
-  auto res = isl_basic_set_n_constraint(get());
-  return res;
+  auto res = isl_basic_set_intersect(copy(), bset2.release());
+  return manage(res);
 }
 
-isl_size basic_set::n_dim() const
+isl::set basic_set::intersect(const isl::set &set2) const
 {
-  auto res = isl_basic_set_n_dim(get());
-  return res;
+  return isl::set(*this).intersect(set2);
 }
 
-isl::basic_set basic_set::nat_universe(isl::space space)
+isl::union_set basic_set::intersect(const isl::union_set &uset2) const
 {
-  auto res = isl_basic_set_nat_universe(space.release());
-  return manage(res);
+  return isl::set(*this).intersect(uset2);
 }
 
-isl::basic_set basic_set::neg() const
+isl::basic_set basic_set::intersect(const isl::point &bset2) const
 {
-  auto res = isl_basic_set_neg(copy());
-  return manage(res);
+  return this->intersect(isl::basic_set(bset2));
 }
 
-isl::basic_set basic_set::params() const
+isl::basic_set basic_set::intersect_params(isl::basic_set bset2) const
 {
-  auto res = isl_basic_set_params(copy());
+  auto res = isl_basic_set_intersect_params(copy(), bset2.release());
   return manage(res);
 }
 
-boolean basic_set::plain_is_empty() const
+isl::set basic_set::intersect_params(const isl::set &params) const
 {
-  auto res = isl_basic_set_plain_is_empty(get());
-  return manage(res);
+  return isl::set(*this).intersect_params(params);
 }
 
-boolean basic_set::plain_is_equal(const isl::basic_set &bset2) const
+isl::basic_set basic_set::intersect_params(const isl::point &bset2) const
 {
-  auto res = isl_basic_set_plain_is_equal(get(), bset2.get());
-  return manage(res);
+  return this->intersect_params(isl::basic_set(bset2));
 }
 
-boolean basic_set::plain_is_universe() const
+boolean basic_set::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_set_plain_is_universe(get());
-  return manage(res);
+  return isl::set(*this).involves_dims(type, first, n);
 }
 
-isl::basic_set basic_set::positive_orthant(isl::space space)
+boolean basic_set::involves_locals() const
 {
-  auto res = isl_basic_set_positive_orthant(space.release());
-  return manage(res);
+  return isl::set(*this).involves_locals();
 }
 
-isl::basic_set basic_set::preimage_multi_aff(isl::multi_aff ma) const
+boolean basic_set::is_bounded() const
 {
-  auto res = isl_basic_set_preimage_multi_aff(copy(), ma.release());
+  auto res = isl_basic_set_is_bounded(get());
   return manage(res);
 }
 
-isl::basic_set basic_set::project_out(isl::dim type, unsigned int first, unsigned int n) const
+boolean basic_set::is_disjoint(const isl::set &set2) const
 {
-  auto res = isl_basic_set_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).is_disjoint(set2);
 }
 
-isl::mat basic_set::reduced_basis() const
+boolean basic_set::is_disjoint(const isl::union_set &uset2) const
 {
-  auto res = isl_basic_set_reduced_basis(get());
-  return manage(res);
+  return isl::set(*this).is_disjoint(uset2);
 }
 
-isl::basic_set basic_set::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
+boolean basic_set::is_empty() const
 {
-  auto res = isl_basic_set_remove_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_basic_set_is_empty(get());
   return manage(res);
 }
 
-isl::basic_set basic_set::remove_divs() const
+boolean basic_set::is_equal(const isl::basic_set &bset2) const
 {
-  auto res = isl_basic_set_remove_divs(copy());
+  auto res = isl_basic_set_is_equal(get(), bset2.get());
   return manage(res);
 }
 
-isl::basic_set basic_set::remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+boolean basic_set::is_equal(const isl::set &set2) const
 {
-  auto res = isl_basic_set_remove_divs_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).is_equal(set2);
 }
 
-isl::basic_set basic_set::remove_redundancies() const
+boolean basic_set::is_equal(const isl::union_set &uset2) const
 {
-  auto res = isl_basic_set_remove_redundancies(copy());
-  return manage(res);
+  return isl::set(*this).is_equal(uset2);
 }
 
-isl::basic_set basic_set::remove_unknown_divs() const
+boolean basic_set::is_equal(const isl::point &bset2) const
 {
-  auto res = isl_basic_set_remove_unknown_divs(copy());
-  return manage(res);
+  return this->is_equal(isl::basic_set(bset2));
 }
 
-isl::basic_set basic_set::sample() const
+boolean basic_set::is_params() const
 {
-  auto res = isl_basic_set_sample(copy());
-  return manage(res);
+  return isl::set(*this).is_params();
 }
 
-isl::point basic_set::sample_point() const
+boolean basic_set::is_singleton() const
 {
-  auto res = isl_basic_set_sample_point(copy());
-  return manage(res);
+  return isl::set(*this).is_singleton();
 }
 
-isl::basic_set basic_set::set_tuple_id(isl::id id) const
+boolean basic_set::is_strict_subset(const isl::set &set2) const
 {
-  auto res = isl_basic_set_set_tuple_id(copy(), id.release());
-  return manage(res);
+  return isl::set(*this).is_strict_subset(set2);
 }
 
-isl::basic_set basic_set::set_tuple_name(const std::string &s) const
+boolean basic_set::is_strict_subset(const isl::union_set &uset2) const
 {
-  auto res = isl_basic_set_set_tuple_name(copy(), s.c_str());
-  return manage(res);
+  return isl::set(*this).is_strict_subset(uset2);
 }
 
-isl::basic_set basic_set::solutions() const
+boolean basic_set::is_subset(const isl::basic_set &bset2) const
 {
-  auto res = isl_basic_set_solutions(copy());
+  auto res = isl_basic_set_is_subset(get(), bset2.get());
   return manage(res);
 }
 
-isl::set basic_set::unite(isl::basic_set bset2) const
+boolean basic_set::is_subset(const isl::set &set2) const
 {
-  auto res = isl_basic_set_union(copy(), bset2.release());
-  return manage(res);
+  return isl::set(*this).is_subset(set2);
 }
 
-isl::basic_set basic_set::universe(isl::space space)
+boolean basic_set::is_subset(const isl::union_set &uset2) const
 {
-  auto res = isl_basic_set_universe(space.release());
-  return manage(res);
+  return isl::set(*this).is_subset(uset2);
 }
 
-isl::basic_map basic_set::unwrap() const
+boolean basic_set::is_subset(const isl::point &bset2) const
 {
-  auto res = isl_basic_set_unwrap(copy());
-  return manage(res);
+  return this->is_subset(isl::basic_set(bset2));
 }
 
-isl::basic_set basic_set::upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const
+boolean basic_set::is_wrapping() const
 {
-  auto res = isl_basic_set_upper_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
+  auto res = isl_basic_set_is_wrapping(get());
   return manage(res);
 }
 
-// implementations for isl::basic_set_list
-basic_set_list manage(__isl_take isl_basic_set_list *ptr) {
-  return basic_set_list(ptr);
-}
-basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr) {
-  ptr = isl_basic_set_list_copy(ptr);
-  return basic_set_list(ptr);
+boolean basic_set::isa_set() const
+{
+  return isl::set(*this).isa_set();
 }
 
-basic_set_list::basic_set_list()
-    : ptr(nullptr) {}
-
-basic_set_list::basic_set_list(const basic_set_list &obj)
-    : ptr(nullptr)
+isl::set basic_set::lexmax() const
 {
-  ptr = obj.copy();
+  auto res = isl_basic_set_lexmax(copy());
+  return manage(res);
 }
 
+isl::pw_multi_aff basic_set::lexmax_pw_multi_aff() const
+{
+  return isl::set(*this).lexmax_pw_multi_aff();
+}
 
-basic_set_list::basic_set_list(__isl_take isl_basic_set_list *ptr)
-    : ptr(ptr) {}
+isl::set basic_set::lexmin() const
+{
+  auto res = isl_basic_set_lexmin(copy());
+  return manage(res);
+}
 
+isl::pw_multi_aff basic_set::lexmin_pw_multi_aff() const
+{
+  return isl::set(*this).lexmin_pw_multi_aff();
+}
 
-basic_set_list &basic_set_list::operator=(basic_set_list obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+isl::set basic_set::lower_bound(const isl::multi_pw_aff &lower) const
+{
+  return isl::set(*this).lower_bound(lower);
 }
 
-basic_set_list::~basic_set_list() {
-  if (ptr)
-    isl_basic_set_list_free(ptr);
+isl::set basic_set::lower_bound(const isl::multi_val &lower) const
+{
+  return isl::set(*this).lower_bound(lower);
 }
 
-__isl_give isl_basic_set_list *basic_set_list::copy() const & {
-  return isl_basic_set_list_copy(ptr);
+isl::set basic_set::lower_bound_si(isl::dim type, unsigned int pos, int value) const
+{
+  return isl::set(*this).lower_bound_si(type, pos, value);
 }
 
-__isl_keep isl_basic_set_list *basic_set_list::get() const {
-  return ptr;
+isl::set basic_set::lower_bound_val(isl::dim type, unsigned int pos, const isl::val &value) const
+{
+  return isl::set(*this).lower_bound_val(type, pos, value);
 }
 
-__isl_give isl_basic_set_list *basic_set_list::release() {
-  isl_basic_set_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::set basic_set::lower_bound_val(isl::dim type, unsigned int pos, long value) const
+{
+  return this->lower_bound_val(type, pos, isl::val(ctx(), value));
 }
 
-bool basic_set_list::is_null() const {
-  return ptr == nullptr;
+isl::multi_pw_aff basic_set::max_multi_pw_aff() const
+{
+  return isl::set(*this).max_multi_pw_aff();
 }
 
+isl::val basic_set::max_val(const isl::aff &obj) const
+{
+  return isl::set(*this).max_val(obj);
+}
 
-isl::ctx basic_set_list::ctx() const {
-  return isl::ctx(isl_basic_set_list_get_ctx(ptr));
+isl::multi_pw_aff basic_set::min_multi_pw_aff() const
+{
+  return isl::set(*this).min_multi_pw_aff();
 }
 
-void basic_set_list::dump() const {
-  isl_basic_set_list_dump(get());
+isl::val basic_set::min_val(const isl::aff &obj) const
+{
+  return isl::set(*this).min_val(obj);
 }
 
+class size basic_set::n_basic_set() const
+{
+  return isl::set(*this).n_basic_set();
+}
 
-isl::basic_set_list basic_set_list::add(isl::basic_set el) const
+isl::basic_set basic_set::params() const
 {
-  auto res = isl_basic_set_list_add(copy(), el.release());
+  auto res = isl_basic_set_params(copy());
   return manage(res);
 }
 
-isl::basic_set_list basic_set_list::alloc(isl::ctx ctx, int n)
+isl::val basic_set::plain_get_val_if_fixed(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_basic_set_list_alloc(ctx.release(), n);
-  return manage(res);
+  return isl::set(*this).plain_get_val_if_fixed(type, pos);
 }
 
-isl::basic_set_list basic_set_list::clear() const
+isl::multi_val basic_set::plain_multi_val_if_fixed() const
 {
-  auto res = isl_basic_set_list_clear(copy());
-  return manage(res);
+  return isl::set(*this).plain_multi_val_if_fixed();
 }
 
-isl::basic_set_list basic_set_list::coefficients() const
+isl::basic_set basic_set::polyhedral_hull() const
 {
-  auto res = isl_basic_set_list_coefficients(copy());
-  return manage(res);
+  return isl::set(*this).polyhedral_hull();
 }
 
-isl::basic_set_list basic_set_list::concat(isl::basic_set_list list2) const
+isl::set basic_set::preimage(const isl::multi_aff &ma) const
 {
-  auto res = isl_basic_set_list_concat(copy(), list2.release());
-  return manage(res);
+  return isl::set(*this).preimage(ma);
 }
 
-isl::basic_set_list basic_set_list::drop(unsigned int first, unsigned int n) const
+isl::set basic_set::preimage(const isl::multi_pw_aff &mpa) const
 {
-  auto res = isl_basic_set_list_drop(copy(), first, n);
-  return manage(res);
+  return isl::set(*this).preimage(mpa);
 }
 
-stat basic_set_list::foreach(const std::function<stat(basic_set)> &fn) const
+isl::set basic_set::preimage(const isl::pw_multi_aff &pma) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_basic_set_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return isl::set(*this).preimage(pma);
 }
 
-isl::basic_set_list basic_set_list::from_basic_set(isl::basic_set el)
+isl::union_set basic_set::preimage(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_basic_set_list_from_basic_set(el.release());
-  return manage(res);
+  return isl::set(*this).preimage(upma);
 }
 
-isl::basic_set basic_set_list::get_at(int index) const
+isl::set basic_set::product(const isl::set &set2) const
 {
-  auto res = isl_basic_set_list_get_at(get(), index);
-  return manage(res);
+  return isl::set(*this).product(set2);
 }
 
-isl::basic_set basic_set_list::get_basic_set(int index) const
+isl::basic_set basic_set::project_out(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_set_list_get_basic_set(get(), index);
+  auto res = isl_basic_set_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::basic_set_list basic_set_list::insert(unsigned int pos, isl::basic_set el) const
+isl::set basic_set::project_out_all_params() const
 {
-  auto res = isl_basic_set_list_insert(copy(), pos, el.release());
-  return manage(res);
+  return isl::set(*this).project_out_all_params();
 }
 
-isl_size basic_set_list::n_basic_set() const
+isl::set basic_set::project_out_param(const isl::id &id) const
 {
-  auto res = isl_basic_set_list_n_basic_set(get());
-  return res;
+  return isl::set(*this).project_out_param(id);
 }
 
-isl::basic_set_list basic_set_list::reverse() const
+isl::set basic_set::project_out_param(const std::string &id) const
 {
-  auto res = isl_basic_set_list_reverse(copy());
-  return manage(res);
+  return this->project_out_param(isl::id(ctx(), id));
 }
 
-isl::basic_set_list basic_set_list::set_basic_set(int index, isl::basic_set el) const
+isl::set basic_set::project_out_param(const isl::id_list &list) const
 {
-  auto res = isl_basic_set_list_set_basic_set(copy(), index, el.release());
-  return manage(res);
+  return isl::set(*this).project_out_param(list);
 }
 
-isl_size basic_set_list::size() const
+isl::pw_multi_aff basic_set::pw_multi_aff_on_domain(const isl::multi_val &mv) const
 {
-  auto res = isl_basic_set_list_size(get());
-  return res;
+  return isl::set(*this).pw_multi_aff_on_domain(mv);
 }
 
-isl::basic_set_list basic_set_list::swap(unsigned int pos1, unsigned int pos2) const
+isl::set basic_set::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_basic_set_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  return isl::set(*this).remove_dims(type, first, n);
 }
 
-// implementations for isl::constraint
-constraint manage(__isl_take isl_constraint *ptr) {
-  return constraint(ptr);
+isl::set basic_set::remove_divs() const
+{
+  return isl::set(*this).remove_divs();
 }
-constraint manage_copy(__isl_keep isl_constraint *ptr) {
-  ptr = isl_constraint_copy(ptr);
-  return constraint(ptr);
+
+isl::set basic_set::remove_redundancies() const
+{
+  return isl::set(*this).remove_redundancies();
 }
 
-constraint::constraint()
-    : ptr(nullptr) {}
+isl::set basic_set::reset_tuple_id() const
+{
+  return isl::set(*this).reset_tuple_id();
+}
 
-constraint::constraint(const constraint &obj)
-    : ptr(nullptr)
+isl::basic_set basic_set::sample() const
 {
-  ptr = obj.copy();
+  auto res = isl_basic_set_sample(copy());
+  return manage(res);
 }
 
+isl::point basic_set::sample_point() const
+{
+  auto res = isl_basic_set_sample_point(copy());
+  return manage(res);
+}
 
-constraint::constraint(__isl_take isl_constraint *ptr)
-    : ptr(ptr) {}
+isl::set basic_set::set_dim_id(isl::dim type, unsigned int pos, const isl::id &id) const
+{
+  return isl::set(*this).set_dim_id(type, pos, id);
+}
 
+isl::set basic_set::set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const
+{
+  return this->set_dim_id(type, pos, isl::id(ctx(), id));
+}
 
-constraint &constraint::operator=(constraint obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+isl::set_list basic_set::set_list() const
+{
+  return isl::set(*this).set_list();
 }
 
-constraint::~constraint() {
-  if (ptr)
-    isl_constraint_free(ptr);
+isl::set basic_set::set_tuple_id(const isl::id &id) const
+{
+  return isl::set(*this).set_tuple_id(id);
 }
 
-__isl_give isl_constraint *constraint::copy() const & {
-  return isl_constraint_copy(ptr);
+isl::set basic_set::set_tuple_id(const std::string &id) const
+{
+  return this->set_tuple_id(isl::id(ctx(), id));
 }
 
-__isl_keep isl_constraint *constraint::get() const {
-  return ptr;
+isl::fixed_box basic_set::simple_fixed_box_hull() const
+{
+  return isl::set(*this).simple_fixed_box_hull();
 }
 
-__isl_give isl_constraint *constraint::release() {
-  isl_constraint *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::basic_set basic_set::simple_hull() const
+{
+  return isl::set(*this).simple_hull();
 }
 
-bool constraint::is_null() const {
-  return ptr == nullptr;
+isl::space basic_set::space() const
+{
+  auto res = isl_basic_set_get_space(get());
+  return manage(res);
 }
 
+isl::space basic_set::get_space() const
+{
+  return space();
+}
 
-isl::ctx constraint::ctx() const {
-  return isl::ctx(isl_constraint_get_ctx(ptr));
+isl::val basic_set::stride(int pos) const
+{
+  return isl::set(*this).stride(pos);
 }
 
-void constraint::dump() const {
-  isl_constraint_dump(get());
+isl::set basic_set::subtract(const isl::set &set2) const
+{
+  return isl::set(*this).subtract(set2);
 }
 
+isl::union_set basic_set::subtract(const isl::union_set &uset2) const
+{
+  return isl::set(*this).subtract(uset2);
+}
 
-isl::constraint constraint::alloc_equality(isl::local_space ls)
+isl::basic_set_list basic_set::to_list() const
 {
-  auto res = isl_constraint_alloc_equality(ls.release());
+  auto res = isl_basic_set_to_list(copy());
   return manage(res);
 }
 
-isl::constraint constraint::alloc_inequality(isl::local_space ls)
+isl::set basic_set::to_set() const
 {
-  auto res = isl_constraint_alloc_inequality(ls.release());
+  auto res = isl_basic_set_to_set(copy());
   return manage(res);
 }
 
-int constraint::cmp_last_non_zero(const isl::constraint &c2) const
+isl::union_set basic_set::to_union_set() const
 {
-  auto res = isl_constraint_cmp_last_non_zero(get(), c2.get());
-  return res;
+  return isl::set(*this).to_union_set();
 }
 
-isl::aff constraint::get_aff() const
+isl::map basic_set::translation() const
 {
-  auto res = isl_constraint_get_aff(get());
-  return manage(res);
+  return isl::set(*this).translation();
 }
 
-isl::aff constraint::get_bound(isl::dim type, int pos) const
+class size basic_set::tuple_dim() const
 {
-  auto res = isl_constraint_get_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::set(*this).tuple_dim();
 }
 
-isl::val constraint::get_coefficient_val(isl::dim type, int pos) const
+isl::id basic_set::tuple_id() const
 {
-  auto res = isl_constraint_get_coefficient_val(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::set(*this).tuple_id();
 }
 
-isl::val constraint::get_constant_val() const
+std::string basic_set::tuple_name() const
 {
-  auto res = isl_constraint_get_constant_val(get());
-  return manage(res);
+  return isl::set(*this).tuple_name();
 }
 
-std::string constraint::get_dim_name(isl::dim type, unsigned int pos) const
+isl::set basic_set::unbind_params(const isl::multi_id &tuple) const
 {
-  auto res = isl_constraint_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return isl::set(*this).unbind_params(tuple);
 }
 
-isl::aff constraint::get_div(int pos) const
+isl::map basic_set::unbind_params_insert_domain(const isl::multi_id &domain) const
 {
-  auto res = isl_constraint_get_div(get(), pos);
-  return manage(res);
+  return isl::set(*this).unbind_params_insert_domain(domain);
 }
 
-isl::local_space constraint::get_local_space() const
+isl::set basic_set::unite(isl::basic_set bset2) const
 {
-  auto res = isl_constraint_get_local_space(get());
+  auto res = isl_basic_set_union(copy(), bset2.release());
   return manage(res);
 }
 
-isl::space constraint::get_space() const
+isl::set basic_set::unite(const isl::set &set2) const
 {
-  auto res = isl_constraint_get_space(get());
-  return manage(res);
+  return isl::set(*this).unite(set2);
 }
 
-boolean constraint::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_set basic_set::unite(const isl::union_set &uset2) const
 {
-  auto res = isl_constraint_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::set(*this).unite(uset2);
 }
 
-boolean constraint::is_div_constraint() const
+isl::set basic_set::unite(const isl::point &bset2) const
 {
-  auto res = isl_constraint_is_div_constraint(get());
-  return manage(res);
+  return this->unite(isl::basic_set(bset2));
 }
 
-boolean constraint::is_lower_bound(isl::dim type, unsigned int pos) const
+isl::basic_set basic_set::universe(isl::space space)
 {
-  auto res = isl_constraint_is_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_basic_set_universe(space.release());
   return manage(res);
 }
 
-boolean constraint::is_upper_bound(isl::dim type, unsigned int pos) const
+isl::basic_set basic_set::unshifted_simple_hull() const
 {
-  auto res = isl_constraint_is_upper_bound(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::set(*this).unshifted_simple_hull();
 }
 
-int constraint::plain_cmp(const isl::constraint &c2) const
+isl::map basic_set::unwrap() const
 {
-  auto res = isl_constraint_plain_cmp(get(), c2.get());
-  return res;
+  return isl::set(*this).unwrap();
 }
 
-isl::constraint constraint::set_coefficient_si(isl::dim type, int pos, int v) const
+isl::set basic_set::upper_bound(const isl::multi_pw_aff &upper) const
 {
-  auto res = isl_constraint_set_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
-  return manage(res);
+  return isl::set(*this).upper_bound(upper);
 }
 
-isl::constraint constraint::set_coefficient_val(isl::dim type, int pos, isl::val v) const
+isl::set basic_set::upper_bound(const isl::multi_val &upper) const
 {
-  auto res = isl_constraint_set_coefficient_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
-  return manage(res);
+  return isl::set(*this).upper_bound(upper);
 }
 
-isl::constraint constraint::set_constant_si(int v) const
+isl::set basic_set::upper_bound_val(isl::dim type, unsigned int pos, const isl::val &value) const
 {
-  auto res = isl_constraint_set_constant_si(copy(), v);
-  return manage(res);
+  return isl::set(*this).upper_bound_val(type, pos, value);
 }
 
-isl::constraint constraint::set_constant_val(isl::val v) const
+isl::set basic_set::upper_bound_val(isl::dim type, unsigned int pos, long value) const
 {
-  auto res = isl_constraint_set_constant_val(copy(), v.release());
-  return manage(res);
+  return this->upper_bound_val(type, pos, isl::val(ctx(), value));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const basic_set &obj)
+{
+  char *str = isl_basic_set_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-// implementations for isl::constraint_list
-constraint_list manage(__isl_take isl_constraint_list *ptr) {
-  return constraint_list(ptr);
+// implementations for isl::basic_set_list
+basic_set_list manage(__isl_take isl_basic_set_list *ptr) {
+  return basic_set_list(ptr);
 }
-constraint_list manage_copy(__isl_keep isl_constraint_list *ptr) {
-  ptr = isl_constraint_list_copy(ptr);
-  return constraint_list(ptr);
+basic_set_list manage_copy(__isl_keep isl_basic_set_list *ptr) {
+  ptr = isl_basic_set_list_copy(ptr);
+  return basic_set_list(ptr);
 }
 
-constraint_list::constraint_list()
+basic_set_list::basic_set_list()
     : ptr(nullptr) {}
 
-constraint_list::constraint_list(const constraint_list &obj)
+basic_set_list::basic_set_list(const basic_set_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
-constraint_list::constraint_list(__isl_take isl_constraint_list *ptr)
+basic_set_list::basic_set_list(__isl_take isl_basic_set_list *ptr)
     : ptr(ptr) {}
 
+basic_set_list::basic_set_list(isl::ctx ctx, int n)
+{
+  auto res = isl_basic_set_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+basic_set_list::basic_set_list(isl::basic_set el)
+{
+  auto res = isl_basic_set_list_from_basic_set(el.release());
+  ptr = res;
+}
 
-constraint_list &constraint_list::operator=(constraint_list obj) {
+basic_set_list &basic_set_list::operator=(basic_set_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
-constraint_list::~constraint_list() {
+basic_set_list::~basic_set_list() {
   if (ptr)
-    isl_constraint_list_free(ptr);
+    isl_basic_set_list_free(ptr);
 }
 
-__isl_give isl_constraint_list *constraint_list::copy() const & {
-  return isl_constraint_list_copy(ptr);
+__isl_give isl_basic_set_list *basic_set_list::copy() const & {
+  return isl_basic_set_list_copy(ptr);
 }
 
-__isl_keep isl_constraint_list *constraint_list::get() const {
+__isl_keep isl_basic_set_list *basic_set_list::get() const {
   return ptr;
 }
 
-__isl_give isl_constraint_list *constraint_list::release() {
-  isl_constraint_list *tmp = ptr;
+__isl_give isl_basic_set_list *basic_set_list::release() {
+  isl_basic_set_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
-bool constraint_list::is_null() const {
+bool basic_set_list::is_null() const {
   return ptr == nullptr;
 }
 
-
-isl::ctx constraint_list::ctx() const {
-  return isl::ctx(isl_constraint_list_get_ctx(ptr));
+isl::ctx basic_set_list::ctx() const {
+  return isl::ctx(isl_basic_set_list_get_ctx(ptr));
 }
 
-void constraint_list::dump() const {
-  isl_constraint_list_dump(get());
+isl::basic_set_list basic_set_list::add(isl::basic_set el) const
+{
+  auto res = isl_basic_set_list_add(copy(), el.release());
+  return manage(res);
 }
 
-
-isl::constraint_list constraint_list::add(isl::constraint el) const
+isl::basic_set basic_set_list::at(int index) const
 {
-  auto res = isl_constraint_list_add(copy(), el.release());
+  auto res = isl_basic_set_list_get_at(get(), index);
   return manage(res);
 }
 
-isl::constraint_list constraint_list::alloc(isl::ctx ctx, int n)
+isl::basic_set basic_set_list::get_at(int index) const
 {
-  auto res = isl_constraint_list_alloc(ctx.release(), n);
-  return manage(res);
+  return at(index);
 }
 
-isl::constraint_list constraint_list::clear() const
+isl::basic_set_list basic_set_list::clear() const
 {
-  auto res = isl_constraint_list_clear(copy());
+  auto res = isl_basic_set_list_clear(copy());
   return manage(res);
 }
 
-isl::constraint_list constraint_list::concat(isl::constraint_list list2) const
+isl::basic_set_list basic_set_list::concat(isl::basic_set_list list2) const
 {
-  auto res = isl_constraint_list_concat(copy(), list2.release());
+  auto res = isl_basic_set_list_concat(copy(), list2.release());
   return manage(res);
 }
 
-isl::constraint_list constraint_list::drop(unsigned int first, unsigned int n) const
+isl::basic_set_list basic_set_list::drop(unsigned int first, unsigned int n) const
 {
-  auto res = isl_constraint_list_drop(copy(), first, n);
+  auto res = isl_basic_set_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat constraint_list::foreach(const std::function<stat(constraint)> &fn) const
+stat basic_set_list::foreach(const std::function<stat(isl::basic_set)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(constraint)> *func;
-  } fn_data = { &fn };
-  auto fn_lambda = [](isl_constraint *arg_0, void *arg_1) -> isl_stat {
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
-  auto res = isl_constraint_list_foreach(get(), fn_lambda, &fn_data);
+  auto res = isl_basic_set_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::constraint_list constraint_list::from_constraint(isl::constraint el)
+isl::basic_set_list basic_set_list::insert(unsigned int pos, isl::basic_set el) const
 {
-  auto res = isl_constraint_list_from_constraint(el.release());
+  auto res = isl_basic_set_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::constraint constraint_list::get_at(int index) const
+class size basic_set_list::size() const
 {
-  auto res = isl_constraint_list_get_at(get(), index);
+  auto res = isl_basic_set_list_size(get());
   return manage(res);
 }
 
-isl::constraint constraint_list::get_constraint(int index) const
+inline std::ostream &operator<<(std::ostream &os, const basic_set_list &obj)
 {
-  auto res = isl_constraint_list_get_constraint(get(), index);
-  return manage(res);
+  char *str = isl_basic_set_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::constraint
+constraint manage(__isl_take isl_constraint *ptr) {
+  return constraint(ptr);
+}
+constraint manage_copy(__isl_keep isl_constraint *ptr) {
+  ptr = isl_constraint_copy(ptr);
+  return constraint(ptr);
+}
+
+constraint::constraint()
+    : ptr(nullptr) {}
+
+constraint::constraint(const constraint &obj)
+    : ptr(nullptr)
+{
+  ptr = obj.copy();
+}
+
+constraint::constraint(__isl_take isl_constraint *ptr)
+    : ptr(ptr) {}
+
+constraint &constraint::operator=(constraint obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+constraint::~constraint() {
+  if (ptr)
+    isl_constraint_free(ptr);
+}
+
+__isl_give isl_constraint *constraint::copy() const & {
+  return isl_constraint_copy(ptr);
+}
+
+__isl_keep isl_constraint *constraint::get() const {
+  return ptr;
+}
+
+__isl_give isl_constraint *constraint::release() {
+  isl_constraint *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool constraint::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::ctx constraint::ctx() const {
+  return isl::ctx(isl_constraint_get_ctx(ptr));
 }
 
-isl::constraint_list constraint_list::insert(unsigned int pos, isl::constraint el) const
+isl::constraint constraint::alloc_equality(isl::local_space ls)
 {
-  auto res = isl_constraint_list_insert(copy(), pos, el.release());
+  auto res = isl_constraint_alloc_equality(ls.release());
   return manage(res);
 }
 
-isl_size constraint_list::n_constraint() const
+isl::constraint constraint::alloc_inequality(isl::local_space ls)
 {
-  auto res = isl_constraint_list_n_constraint(get());
-  return res;
+  auto res = isl_constraint_alloc_inequality(ls.release());
+  return manage(res);
 }
 
-isl::constraint_list constraint_list::reverse() const
+isl::constraint constraint::set_coefficient_si(isl::dim type, int pos, int v) const
 {
-  auto res = isl_constraint_list_reverse(copy());
+  auto res = isl_constraint_set_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
   return manage(res);
 }
 
-isl::constraint_list constraint_list::set_constraint(int index, isl::constraint el) const
+isl::constraint constraint::set_constant_si(int v) const
 {
-  auto res = isl_constraint_list_set_constraint(copy(), index, el.release());
+  auto res = isl_constraint_set_constant_si(copy(), v);
   return manage(res);
 }
 
-isl_size constraint_list::size() const
+isl::constraint constraint::set_constant_val(isl::val v) const
 {
-  auto res = isl_constraint_list_size(get());
-  return res;
+  auto res = isl_constraint_set_constant_val(copy(), v.release());
+  return manage(res);
 }
 
-isl::constraint_list constraint_list::swap(unsigned int pos1, unsigned int pos2) const
+isl::constraint constraint::set_constant_val(long v) const
 {
-  auto res = isl_constraint_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  return this->set_constant_val(isl::val(ctx(), v));
 }
 
 // implementations for isl::fixed_box
 fixed_box manage(__isl_take isl_fixed_box *ptr) {
   return fixed_box(ptr);
 }
 fixed_box manage_copy(__isl_keep isl_fixed_box *ptr) {
   ptr = isl_fixed_box_copy(ptr);
   return fixed_box(ptr);
 }
 
 fixed_box::fixed_box()
     : ptr(nullptr) {}
 
 fixed_box::fixed_box(const fixed_box &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 fixed_box::fixed_box(__isl_take isl_fixed_box *ptr)
     : ptr(ptr) {}
 
-
 fixed_box &fixed_box::operator=(fixed_box obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 fixed_box::~fixed_box() {
   if (ptr)
     isl_fixed_box_free(ptr);
__isl_give isl_fixed_box *fixed_box::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool fixed_box::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx fixed_box::ctx() const {
   return isl::ctx(isl_fixed_box_get_ctx(ptr));
 }
 
-void fixed_box::dump() const {
-  isl_fixed_box_dump(get());
+boolean fixed_box::is_valid() const
+{
+  auto res = isl_fixed_box_is_valid(get());
+  return manage(res);
 }
 
-
-isl::multi_aff fixed_box::get_offset() const
+isl::multi_aff fixed_box::offset() const
 {
   auto res = isl_fixed_box_get_offset(get());
   return manage(res);
 }
 
-isl::multi_val fixed_box::get_size() const
+isl::multi_aff fixed_box::get_offset() const
+{
+  return offset();
+}
+
+isl::multi_val fixed_box::size() const
 {
   auto res = isl_fixed_box_get_size(get());
   return manage(res);
 }
 
-isl::space fixed_box::get_space() const
+isl::multi_val fixed_box::get_size() const
+{
+  return size();
+}
+
+isl::space fixed_box::space() const
 {
   auto res = isl_fixed_box_get_space(get());
   return manage(res);
 }
 
-boolean fixed_box::is_valid() const
+isl::space fixed_box::get_space() const
 {
-  auto res = isl_fixed_box_is_valid(get());
-  return manage(res);
+  return space();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const fixed_box &obj)
+{
+  char *str = isl_fixed_box_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::id
 id manage(__isl_take isl_id *ptr) {
   return id(ptr);
 }
 id manage_copy(__isl_keep isl_id *ptr) {
   ptr = isl_id_copy(ptr);
   return id(ptr);
 }
 
 id::id()
     : ptr(nullptr) {}
 
 id::id(const id &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 id::id(__isl_take isl_id *ptr)
     : ptr(ptr) {}
 
 id::id(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_id_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
__isl_give isl_id *id::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool id::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx id::ctx() const {
   return isl::ctx(isl_id_get_ctx(ptr));
 }
 
-void id::dump() const {
-  isl_id_dump(get());
-}
-
-
 isl::id id::alloc(isl::ctx ctx, const std::string &name, void * user)
 {
   auto res = isl_id_alloc(ctx.release(), name.c_str(), user);
   return manage(res);
 }
 
-uint32_t id::get_hash() const
+std::string id::name() const
 {
-  auto res = isl_id_get_hash(get());
-  return res;
+  auto res = isl_id_get_name(get());
+  std::string tmp(res);
+  return tmp;
 }
 
 std::string id::get_name() const
 {
-  auto res = isl_id_get_name(get());
-  std::string tmp(res);
-  return tmp;
+  return name();
 }
 
-void * id::get_user() const
+isl::id_list id::to_list() const
+{
+  auto res = isl_id_to_list(copy());
+  return manage(res);
+}
+
+void * id::user() const
 {
   auto res = isl_id_get_user(get());
   return res;
 }
 
+void * id::get_user() const
+{
+  return user();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const id &obj)
+{
+  char *str = isl_id_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::id_list
 id_list manage(__isl_take isl_id_list *ptr) {
   return id_list(ptr);
 }
 id_list manage_copy(__isl_keep isl_id_list *ptr) {
   ptr = isl_id_list_copy(ptr);
   return id_list(ptr);
 }
 
 id_list::id_list()
     : ptr(nullptr) {}
 
 id_list::id_list(const id_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 id_list::id_list(__isl_take isl_id_list *ptr)
     : ptr(ptr) {}
 
+id_list::id_list(isl::ctx ctx, int n)
+{
+  auto res = isl_id_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+id_list::id_list(isl::id el)
+{
+  auto res = isl_id_list_from_id(el.release());
+  ptr = res;
+}
+
+id_list::id_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_id_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 id_list &id_list::operator=(id_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 id_list::~id_list() {
   if (ptr)
__isl_give isl_id_list *id_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool id_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx id_list::ctx() const {
   return isl::ctx(isl_id_list_get_ctx(ptr));
 }
 
-void id_list::dump() const {
-  isl_id_list_dump(get());
-}
-
-
 isl::id_list id_list::add(isl::id el) const
 {
   auto res = isl_id_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::id_list id_list::alloc(isl::ctx ctx, int n)
+isl::id_list id_list::add(const std::string &el) const
 {
-  auto res = isl_id_list_alloc(ctx.release(), n);
+  return this->add(isl::id(ctx(), el));
+}
+
+isl::id id_list::at(int index) const
+{
+  auto res = isl_id_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::id id_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::id_list id_list::clear() const
 {
   auto res = isl_id_list_clear(copy());
   return manage(res);
 }
 
 isl::id_list id_list::concat(isl::id_list list2) const
 {
   auto res = isl_id_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::id_list id_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_id_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat id_list::foreach(const std::function<stat(id)> &fn) const
+stat id_list::foreach(const std::function<stat(isl::id)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(id)> *func;
-  } fn_data = { &fn };
+    std::function<stat(isl::id)> func;
+  } fn_data = { fn };
   auto fn_lambda = [](isl_id *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_id_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::id_list id_list::from_id(isl::id el)
-{
-  auto res = isl_id_list_from_id(el.release());
-  return manage(res);
-}
-
-isl::id id_list::get_at(int index) const
-{
-  auto res = isl_id_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::id id_list::get_id(int index) const
-{
-  auto res = isl_id_list_get_id(get(), index);
-  return manage(res);
-}
-
 isl::id_list id_list::insert(unsigned int pos, isl::id el) const
 {
   auto res = isl_id_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size id_list::n_id() const
-{
-  auto res = isl_id_list_n_id(get());
-  return res;
-}
-
-isl::id_list id_list::reverse() const
-{
-  auto res = isl_id_list_reverse(copy());
-  return manage(res);
-}
-
-isl::id_list id_list::set_id(int index, isl::id el) const
+isl::id_list id_list::insert(unsigned int pos, const std::string &el) const
 {
-  auto res = isl_id_list_set_id(copy(), index, el.release());
-  return manage(res);
+  return this->insert(pos, isl::id(ctx(), el));
 }
 
-isl_size id_list::size() const
+class size id_list::size() const
 {
   auto res = isl_id_list_size(get());
-  return res;
+  return manage(res);
 }
 
-isl::id_list id_list::swap(unsigned int pos1, unsigned int pos2) const
+inline std::ostream &operator<<(std::ostream &os, const id_list &obj)
 {
-  auto res = isl_id_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_id_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::id_to_ast_expr
 id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr) {
   return id_to_ast_expr(ptr);
 }
 id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr) {
   ptr = isl_id_to_ast_expr_copy(ptr);
   return id_to_ast_expr(ptr);
 }
 
 id_to_ast_expr::id_to_ast_expr()
     : ptr(nullptr) {}
 
 id_to_ast_expr::id_to_ast_expr(const id_to_ast_expr &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 id_to_ast_expr::id_to_ast_expr(__isl_take isl_id_to_ast_expr *ptr)
     : ptr(ptr) {}
 
-
 id_to_ast_expr &id_to_ast_expr::operator=(id_to_ast_expr obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 id_to_ast_expr::~id_to_ast_expr() {
   if (ptr)
     isl_id_to_ast_expr_free(ptr);
__isl_give isl_id_to_ast_expr *id_to_ast_expr::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool id_to_ast_expr::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx id_to_ast_expr::ctx() const {
   return isl::ctx(isl_id_to_ast_expr_get_ctx(ptr));
 }
 
-void id_to_ast_expr::dump() const {
-  isl_id_to_ast_expr_dump(get());
-}
-
-
 isl::id_to_ast_expr id_to_ast_expr::alloc(isl::ctx ctx, int min_size)
 {
   auto res = isl_id_to_ast_expr_alloc(ctx.release(), min_size);
   return manage(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);
-}
-
-stat id_to_ast_expr::foreach(const std::function<stat(id, ast_expr)> &fn) const
-{
-  struct fn_data {
-    const std::function<stat(id, 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)(manage(arg_0), manage(arg_1));
-    return ret.release();
-  };
-  auto res = isl_id_to_ast_expr_foreach(get(), fn_lambda, &fn_data);
-  return manage(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);
-}
-
-boolean id_to_ast_expr::has(const isl::id &key) const
+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_has(get(), key.get());
+  auto res = isl_id_to_ast_expr_set(copy(), key.release(), val.release());
   return manage(res);
 }
 
-isl::id_to_ast_expr id_to_ast_expr::set(isl::id key, isl::ast_expr val) const
+isl::id_to_ast_expr id_to_ast_expr::set(const std::string &key, const isl::ast_expr &val) const
 {
-  auto res = isl_id_to_ast_expr_set(copy(), key.release(), val.release());
-  return manage(res);
+  return this->set(isl::id(ctx(), key), val);
 }
 
 // implementations for isl::local_space
 local_space manage(__isl_take isl_local_space *ptr) {
   return local_space(ptr);
 }
 local_space manage_copy(__isl_keep isl_local_space *ptr) {
   ptr = isl_local_space_copy(ptr);
   return local_space(ptr);
 }
 
 local_space::local_space()
     : ptr(nullptr) {}
 
 local_space::local_space(const local_space &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 local_space::local_space(__isl_take isl_local_space *ptr)
     : ptr(ptr) {}
 
 local_space::local_space(isl::space space)
 {
   auto res = isl_local_space_from_space(space.release());
   ptr = res;
 }
__isl_give isl_local_space *local_space::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool local_space::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx local_space::ctx() const {
   return isl::ctx(isl_local_space_get_ctx(ptr));
 }
 
-void local_space::dump() const {
-  isl_local_space_dump(get());
-}
-
-
-isl::local_space local_space::add_dims(isl::dim type, unsigned int n) const
-{
-  auto res = isl_local_space_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
-}
-
-isl_size local_space::dim(isl::dim type) const
-{
-  auto res = isl_local_space_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
-}
-
-isl::local_space local_space::domain() const
-{
-  auto res = isl_local_space_domain(copy());
-  return manage(res);
-}
-
-isl::local_space local_space::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_local_space_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
-int local_space::find_dim_by_name(isl::dim type, const std::string &name) const
-{
-  auto res = isl_local_space_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
-}
-
-isl::local_space local_space::flatten_domain() const
-{
-  auto res = isl_local_space_flatten_domain(copy());
-  return manage(res);
-}
-
-isl::local_space local_space::flatten_range() const
-{
-  auto res = isl_local_space_flatten_range(copy());
-  return manage(res);
-}
-
-isl::local_space local_space::from_domain() const
-{
-  auto res = isl_local_space_from_domain(copy());
-  return manage(res);
-}
-
-isl::id local_space::get_dim_id(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_local_space_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
-}
-
-std::string local_space::get_dim_name(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_local_space_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
-}
-
-isl::aff local_space::get_div(int pos) const
-{
-  auto res = isl_local_space_get_div(get(), pos);
-  return manage(res);
-}
-
-isl::space local_space::get_space() const
-{
-  auto res = isl_local_space_get_space(get());
-  return manage(res);
-}
-
-boolean local_space::has_dim_id(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_local_space_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
-}
-
-boolean local_space::has_dim_name(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_local_space_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(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);
-}
-
-boolean local_space::is_equal(const isl::local_space &ls2) const
-{
-  auto res = isl_local_space_is_equal(get(), ls2.get());
-  return manage(res);
-}
-
-boolean local_space::is_params() const
-{
-  auto res = isl_local_space_is_params(get());
-  return manage(res);
-}
-
-boolean local_space::is_set() const
-{
-  auto res = isl_local_space_is_set(get());
-  return manage(res);
-}
-
-isl::local_space local_space::range() const
-{
-  auto res = isl_local_space_range(copy());
-  return manage(res);
-}
-
-isl::local_space local_space::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
-{
-  auto res = isl_local_space_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
-}
-
-isl::local_space local_space::set_from_params() const
-{
-  auto res = isl_local_space_set_from_params(copy());
-  return manage(res);
-}
-
-isl::local_space local_space::set_tuple_id(isl::dim type, isl::id id) const
-{
-  auto res = isl_local_space_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
-  return manage(res);
-}
-
-isl::local_space local_space::wrap() const
-{
-  auto res = isl_local_space_wrap(copy());
-  return manage(res);
-}
-
 // implementations for isl::map
 map manage(__isl_take isl_map *ptr) {
   return map(ptr);
 }
 map manage_copy(__isl_keep isl_map *ptr) {
   ptr = isl_map_copy(ptr);
   return map(ptr);
 }
 
 map::map()
     : ptr(nullptr) {}
 
 map::map(const map &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 map::map(__isl_take isl_map *ptr)
     : ptr(ptr) {}
 
 map::map(isl::basic_map bmap)
 {
   auto res = isl_map_from_basic_map(bmap.release());
   ptr = res;
 }
+
 map::map(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_map_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 map &map::operator=(map obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_map *map::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool map::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx map::ctx() const {
   return isl::ctx(isl_map_get_ctx(ptr));
 }
 
-void map::dump() const {
-  isl_map_dump(get());
-}
-
-
 isl::map map::add_constraint(isl::constraint constraint) const
 {
   auto res = isl_map_add_constraint(copy(), constraint.release());
   return manage(res);
 }
 
 isl::map map::add_dims(isl::dim type, unsigned int n) const
 {

 }
 
 isl::map map::apply_domain(isl::map map2) const
 {
   auto res = isl_map_apply_domain(copy(), map2.release());
   return manage(res);
 }
 
+isl::union_map map::apply_domain(const isl::union_map &umap2) const
+{
+  return isl::union_map(*this).apply_domain(umap2);
+}
+
+isl::map map::apply_domain(const isl::basic_map &map2) const
+{
+  return this->apply_domain(isl::map(map2));
+}
+
 isl::map map::apply_range(isl::map map2) const
 {
   auto res = isl_map_apply_range(copy(), map2.release());
   return manage(res);
 }
 
-isl::set map::bind_domain(isl::multi_id tuple) const
+isl::union_map map::apply_range(const isl::union_map &umap2) const
 {
-  auto res = isl_map_bind_domain(copy(), tuple.release());
-  return manage(res);
+  return isl::union_map(*this).apply_range(umap2);
 }
 
-isl::set map::bind_range(isl::multi_id tuple) const
+isl::map map::apply_range(const isl::basic_map &map2) const
 {
-  auto res = isl_map_bind_range(copy(), tuple.release());
+  return this->apply_range(isl::map(map2));
+}
+
+isl::map map::as_map() const
+{
+  return isl::union_map(*this).as_map();
+}
+
+isl::multi_union_pw_aff map::as_multi_union_pw_aff() const
+{
+  return isl::union_map(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff map::as_pw_multi_aff() const
+{
+  auto res = isl_map_as_pw_multi_aff(copy());
   return manage(res);
 }
 
-boolean map::can_curry() const
+isl::union_pw_multi_aff map::as_union_pw_multi_aff() const
 {
-  auto res = isl_map_can_curry(get());
+  return isl::union_map(*this).as_union_pw_multi_aff();
+}
+
+isl::basic_map_list map::basic_map_list() const
+{
+  auto res = isl_map_get_basic_map_list(get());
   return manage(res);
 }
 
-boolean map::can_range_curry() const
+isl::basic_map_list map::get_basic_map_list() const
+{
+  return basic_map_list();
+}
+
+isl::set map::bind_domain(isl::multi_id tuple) const
 {
-  auto res = isl_map_can_range_curry(get());
+  auto res = isl_map_bind_domain(copy(), tuple.release());
   return manage(res);
 }
 
-boolean map::can_uncurry() const
+isl::set map::bind_range(isl::multi_id tuple) const
 {
-  auto res = isl_map_can_uncurry(get());
+  auto res = isl_map_bind_range(copy(), tuple.release());
   return manage(res);
 }
 
-boolean map::can_zip() const
+boolean map::can_curry() const
 {
-  auto res = isl_map_can_zip(get());
+  auto res = isl_map_can_curry(get());
   return manage(res);
 }
 
 isl::map map::coalesce() const
 {
   auto res = isl_map_coalesce(copy());
   return manage(res);
 }
 
 isl::map map::complement() const
 {
   auto res = isl_map_complement(copy());
   return manage(res);
 }
 
-isl::basic_map map::convex_hull() const
+isl::union_map map::compute_divs() const
 {
-  auto res = isl_map_convex_hull(copy());
-  return manage(res);
+  return isl::union_map(*this).compute_divs();
 }
 
 isl::map map::curry() const
 {
   auto res = isl_map_curry(copy());
   return manage(res);
 }
 
 isl::set map::deltas() const
 {
   auto res = isl_map_deltas(copy());
   return manage(res);
 }
 
-isl::map map::deltas_map() const
-{
-  auto res = isl_map_deltas_map(copy());
-  return manage(res);
-}
-
 isl::map map::detect_equalities() const
 {
   auto res = isl_map_detect_equalities(copy());
   return manage(res);
 }
 
-isl_size map::dim(isl::dim type) const
+class size map::dim(isl::dim type) const
 {
   auto res = isl_map_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return manage(res);
 }
 
 isl::pw_aff map::dim_max(int pos) const
 {
   auto res = isl_map_dim_max(copy(), pos);
   return manage(res);
 }
 

 }
 
 isl::map map::domain_factor_range() const
 {
   auto res = isl_map_domain_factor_range(copy());
   return manage(res);
 }
 
-boolean map::domain_is_wrapping() const
+isl::map map::domain_map() const
 {
-  auto res = isl_map_domain_is_wrapping(get());
+  auto res = isl_map_domain_map(copy());
   return manage(res);
 }
 
-isl::map map::domain_map() const
+isl::union_pw_multi_aff map::domain_map_union_pw_multi_aff() const
 {
-  auto res = isl_map_domain_map(copy());
-  return manage(res);
+  return isl::union_map(*this).domain_map_union_pw_multi_aff();
 }
 
 isl::map map::domain_product(isl::map map2) const
 {
   auto res = isl_map_domain_product(copy(), map2.release());
   return manage(res);
 }
 
-isl_size map::domain_tuple_dim() const
+isl::union_map map::domain_product(const isl::union_map &umap2) const
 {
-  auto res = isl_map_domain_tuple_dim(get());
-  return res;
+  return isl::union_map(*this).domain_product(umap2);
 }
 
-isl::map map::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::map map::domain_product(const isl::basic_map &map2) const
 {
-  auto res = isl_map_drop_constraints_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->domain_product(isl::map(map2));
 }
 
-isl::map map::drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+class size map::domain_tuple_dim() const
 {
-  auto res = isl_map_drop_constraints_not_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_map_domain_tuple_dim(get());
   return manage(res);
 }
 
-isl::map map::drop_unused_params() const
+isl::id map::domain_tuple_id() const
 {
-  auto res = isl_map_drop_unused_params(copy());
+  auto res = isl_map_get_domain_tuple_id(get());
   return manage(res);
 }
 
-isl::map map::eliminate(isl::dim type, unsigned int first, unsigned int n) const
+isl::id map::get_domain_tuple_id() const
 {
-  auto res = isl_map_eliminate(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return domain_tuple_id();
 }
 
 isl::map map::empty(isl::space space)
 {
   auto res = isl_map_empty(space.release());
   return manage(res);
 }
 
 isl::map map::eq_at(isl::multi_pw_aff mpa) const
 {
   auto res = isl_map_eq_at_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
-isl::map map::equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::union_map map::eq_at(const isl::multi_union_pw_aff &mupa) const
 {
-  auto res = isl_map_equate(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
-  return manage(res);
+  return isl::union_map(*this).eq_at(mupa);
 }
 
-isl::map map::factor_domain() const
+isl::map map::eq_at(const isl::aff &mpa) const
 {
-  auto res = isl_map_factor_domain(copy());
-  return manage(res);
+  return this->eq_at(isl::multi_pw_aff(mpa));
 }
 
-isl::map map::factor_range() const
+isl::map map::eq_at(const isl::multi_aff &mpa) const
 {
-  auto res = isl_map_factor_range(copy());
-  return manage(res);
+  return this->eq_at(isl::multi_pw_aff(mpa));
 }
 
-int map::find_dim_by_id(isl::dim type, const isl::id &id) const
+isl::map map::eq_at(const isl::pw_aff &mpa) const
 {
-  auto res = isl_map_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
-  return res;
+  return this->eq_at(isl::multi_pw_aff(mpa));
 }
 
-int map::find_dim_by_name(isl::dim type, const std::string &name) const
+isl::map map::eq_at(const isl::pw_multi_aff &mpa) const
 {
-  auto res = isl_map_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return this->eq_at(isl::multi_pw_aff(mpa));
 }
 
-isl::map map::fix_si(isl::dim type, unsigned int pos, int value) const
+isl::map map::equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 {
-  auto res = isl_map_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
+  auto res = isl_map_equate(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
   return manage(res);
 }
 
-isl::map map::fix_val(isl::dim type, unsigned int pos, isl::val v) const
+boolean map::every_map(const std::function<boolean(isl::map)> &test) const
 {
-  auto res = isl_map_fix_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
-  return manage(res);
+  return isl::union_map(*this).every_map(test);
 }
 
-isl::map map::fixed_power_val(isl::val exp) const
+isl::map map::extract_map(const isl::space &space) const
 {
-  auto res = isl_map_fixed_power_val(copy(), exp.release());
+  return isl::union_map(*this).extract_map(space);
+}
+
+isl::map map::factor_domain() const
+{
+  auto res = isl_map_factor_domain(copy());
   return manage(res);
 }
 
-isl::map map::flat_domain_product(isl::map map2) const
+isl::map map::factor_range() const
 {
-  auto res = isl_map_flat_domain_product(copy(), map2.release());
+  auto res = isl_map_factor_range(copy());
   return manage(res);
 }
 
-isl::map map::flat_product(isl::map map2) const
+isl::map map::fix_si(isl::dim type, unsigned int pos, int value) const
 {
-  auto res = isl_map_flat_product(copy(), map2.release());
+  auto res = isl_map_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
   return manage(res);
 }
 
+isl::union_map map::fixed_power(const isl::val &exp) const
+{
+  return isl::union_map(*this).fixed_power(exp);
+}
+
+isl::union_map map::fixed_power(long exp) const
+{
+  return this->fixed_power(isl::val(ctx(), exp));
+}
+
 isl::map map::flat_range_product(isl::map map2) const
 {
   auto res = isl_map_flat_range_product(copy(), map2.release());
   return manage(res);
 }
 
+isl::union_map map::flat_range_product(const isl::union_map &umap2) const
+{
+  return isl::union_map(*this).flat_range_product(umap2);
+}
+
+isl::map map::flat_range_product(const isl::basic_map &map2) const
+{
+  return this->flat_range_product(isl::map(map2));
+}
+
 isl::map map::flatten() const
 {
   auto res = isl_map_flatten(copy());
   return manage(res);
 }
 
 isl::map map::flatten_domain() const
 {
   auto res = isl_map_flatten_domain(copy());
   return manage(res);
 }
 
 isl::map map::flatten_range() const
 {
   auto res = isl_map_flatten_range(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);
 }
 
-stat map::foreach_basic_map(const std::function<stat(basic_map)> &fn) const
+isl::map map::floordiv_val(long d) const
+{
+  return this->floordiv_val(isl::val(ctx(), d));
+}
+
+stat map::foreach_basic_map(const std::function<stat(isl::basic_map)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(basic_map)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_map_foreach_basic_map(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
+stat map::foreach_map(const std::function<stat(isl::map)> &fn) const
+{
+  return isl::union_map(*this).foreach_map(fn);
+}
+
 isl::map map::from_aff(isl::aff aff)
 {
   auto res = isl_map_from_aff(aff.release());
   return manage(res);
 }
 
 isl::map map::from_domain(isl::set set)
 {
   auto res = isl_map_from_domain(set.release());
   return manage(res);
 }
 
 isl::map map::from_domain_and_range(isl::set domain, isl::set range)
 {
   auto res = isl_map_from_domain_and_range(domain.release(), range.release());
   return manage(res);
 }
 
 isl::map map::from_multi_aff(isl::multi_aff maff)
 {
   auto res = isl_map_from_multi_aff(maff.release());
   return manage(res);
 }
 
-isl::map map::from_multi_pw_aff(isl::multi_pw_aff mpa)
-{
-  auto res = isl_map_from_multi_pw_aff(mpa.release());
-  return manage(res);
-}
-
 isl::map map::from_pw_aff(isl::pw_aff pwaff)
 {
   auto res = isl_map_from_pw_aff(pwaff.release());
   return manage(res);
 }
 
-isl::map map::from_pw_multi_aff(isl::pw_multi_aff pma)
-{
-  auto res = isl_map_from_pw_multi_aff(pma.release());
-  return manage(res);
-}
-
 isl::map map::from_range(isl::set set)
 {
   auto res = isl_map_from_range(set.release());
   return manage(res);
 }
 
 isl::map map::from_union_map(isl::union_map umap)
 {
   auto res = isl_map_from_union_map(umap.release());
   return manage(res);
 }
 
-isl::basic_map_list map::get_basic_map_list() const
+isl::map map::gist(isl::map context) const
 {
-  auto res = isl_map_get_basic_map_list(get());
+  auto res = isl_map_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::id map::get_dim_id(isl::dim type, unsigned int pos) const
+isl::union_map map::gist(const isl::union_map &context) const
 {
-  auto res = isl_map_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::union_map(*this).gist(context);
 }
 
-std::string map::get_dim_name(isl::dim type, unsigned int pos) const
+isl::map map::gist(const isl::basic_map &context) const
 {
-  auto res = isl_map_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return this->gist(isl::map(context));
 }
 
-uint32_t map::get_hash() const
+isl::map map::gist_domain(isl::set context) const
 {
-  auto res = isl_map_get_hash(get());
-  return res;
+  auto res = isl_map_gist_domain(copy(), context.release());
+  return manage(res);
 }
 
-isl::fixed_box map::get_range_simple_fixed_box_hull() const
+isl::union_map map::gist_domain(const isl::union_set &uset) const
 {
-  auto res = isl_map_get_range_simple_fixed_box_hull(get());
-  return manage(res);
+  return isl::union_map(*this).gist_domain(uset);
 }
 
-isl::space map::get_space() const
+isl::map map::gist_domain(const isl::basic_set &context) const
 {
-  auto res = isl_map_get_space(get());
-  return manage(res);
+  return this->gist_domain(isl::set(context));
 }
 
-isl::id map::get_tuple_id(isl::dim type) const
+isl::map map::gist_domain(const isl::point &context) const
 {
-  auto res = isl_map_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  return this->gist_domain(isl::set(context));
+}
+
+isl::map map::gist_params(isl::set context) const
+{
+  auto res = isl_map_gist_params(copy(), context.release());
   return manage(res);
 }
 
-std::string map::get_tuple_name(isl::dim type) const
+isl::union_map map::gist_range(const isl::union_set &uset) const
 {
-  auto res = isl_map_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
+  return isl::union_map(*this).gist_range(uset);
 }
 
-isl::map map::gist(isl::map context) const
+boolean map::has_domain_tuple_id() const
 {
-  auto res = isl_map_gist(copy(), context.release());
+  auto res = isl_map_has_domain_tuple_id(get());
   return manage(res);
 }
 
-isl::map map::gist_basic_map(isl::basic_map context) const
+boolean map::has_equal_space(const isl::map &map2) const
 {
-  auto res = isl_map_gist_basic_map(copy(), context.release());
+  auto res = isl_map_has_equal_space(get(), map2.get());
   return manage(res);
 }
 
-isl::map map::gist_domain(isl::set context) const
+boolean map::has_range_tuple_id() const
 {
-  auto res = isl_map_gist_domain(copy(), context.release());
+  auto res = isl_map_has_range_tuple_id(get());
   return manage(res);
 }
 
-isl::map map::gist_params(isl::set context) const
+boolean map::has_tuple_id(isl::dim type) const
 {
-  auto res = isl_map_gist_params(copy(), context.release());
+  auto res = isl_map_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::map map::gist_range(isl::set context) const
+boolean map::has_tuple_name(isl::dim type) const
 {
-  auto res = isl_map_gist_range(copy(), context.release());
+  auto res = isl_map_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean map::has_dim_id(isl::dim type, unsigned int pos) const
+isl::map map::identity(isl::space space)
 {
-  auto res = isl_map_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_map_identity(space.release());
   return manage(res);
 }
 
-boolean map::has_dim_name(isl::dim type, unsigned int pos) const
+isl::map map::intersect(isl::map map2) const
 {
-  auto res = isl_map_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_map_intersect(copy(), map2.release());
   return manage(res);
 }
 
-boolean map::has_equal_space(const isl::map &map2) const
+isl::union_map map::intersect(const isl::union_map &umap2) const
 {
-  auto res = isl_map_has_equal_space(get(), map2.get());
-  return manage(res);
+  return isl::union_map(*this).intersect(umap2);
 }
 
-boolean map::has_tuple_id(isl::dim type) const
+isl::map map::intersect(const isl::basic_map &map2) const
 {
-  auto res = isl_map_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return this->intersect(isl::map(map2));
 }
 
-boolean map::has_tuple_name(isl::dim type) const
+isl::map map::intersect_domain(isl::set set) const
 {
-  auto res = isl_map_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_map_intersect_domain(copy(), set.release());
   return manage(res);
 }
 
-isl::map map::identity(isl::space space)
+isl::union_map map::intersect_domain(const isl::space &space) const
 {
-  auto res = isl_map_identity(space.release());
-  return manage(res);
+  return isl::union_map(*this).intersect_domain(space);
 }
 
-isl::map map::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
+isl::union_map map::intersect_domain(const isl::union_set &uset) const
 {
-  auto res = isl_map_insert_dims(copy(), static_cast<enum isl_dim_type>(type), pos, n);
-  return manage(res);
+  return isl::union_map(*this).intersect_domain(uset);
 }
 
-isl::map map::intersect(isl::map map2) const
+isl::map map::intersect_domain(const isl::basic_set &set) const
 {
-  auto res = isl_map_intersect(copy(), map2.release());
-  return manage(res);
+  return this->intersect_domain(isl::set(set));
 }
 
-isl::map map::intersect_domain(isl::set set) const
+isl::map map::intersect_domain(const isl::point &set) const
 {
-  auto res = isl_map_intersect_domain(copy(), set.release());
-  return manage(res);
+  return this->intersect_domain(isl::set(set));
 }
 
 isl::map map::intersect_domain_factor_domain(isl::map factor) const
 {
   auto res = isl_map_intersect_domain_factor_domain(copy(), factor.release());
   return manage(res);
 }
 
+isl::union_map map::intersect_domain_factor_domain(const isl::union_map &factor) const
+{
+  return isl::union_map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::map map::intersect_domain_factor_domain(const isl::basic_map &factor) const
+{
+  return this->intersect_domain_factor_domain(isl::map(factor));
+}
+
 isl::map map::intersect_domain_factor_range(isl::map factor) const
 {
   auto res = isl_map_intersect_domain_factor_range(copy(), factor.release());
   return manage(res);
 }
 
+isl::union_map map::intersect_domain_factor_range(const isl::union_map &factor) const
+{
+  return isl::union_map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::map map::intersect_domain_factor_range(const isl::basic_map &factor) const
+{
+  return this->intersect_domain_factor_range(isl::map(factor));
+}
+
 isl::map map::intersect_params(isl::set params) const
 {
   auto res = isl_map_intersect_params(copy(), params.release());
   return manage(res);
 }
 
 isl::map map::intersect_range(isl::set set) const
 {
   auto res = isl_map_intersect_range(copy(), set.release());
   return manage(res);
 }
 
+isl::union_map map::intersect_range(const isl::space &space) const
+{
+  return isl::union_map(*this).intersect_range(space);
+}
+
+isl::union_map map::intersect_range(const isl::union_set &uset) const
+{
+  return isl::union_map(*this).intersect_range(uset);
+}
+
+isl::map map::intersect_range(const isl::basic_set &set) const
+{
+  return this->intersect_range(isl::set(set));
+}
+
+isl::map map::intersect_range(const isl::point &set) const
+{
+  return this->intersect_range(isl::set(set));
+}
+
 isl::map map::intersect_range_factor_domain(isl::map factor) const
 {
   auto res = isl_map_intersect_range_factor_domain(copy(), factor.release());
   return manage(res);
 }
 
+isl::union_map map::intersect_range_factor_domain(const isl::union_map &factor) const
+{
+  return isl::union_map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::map map::intersect_range_factor_domain(const isl::basic_map &factor) const
+{
+  return this->intersect_range_factor_domain(isl::map(factor));
+}
+
 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::union_map map::intersect_range_factor_range(const isl::union_map &factor) const
+{
+  return isl::union_map(*this).intersect_range_factor_range(factor);
+}
+
+isl::map map::intersect_range_factor_range(const isl::basic_map &factor) const
+{
+  return this->intersect_range_factor_range(isl::map(factor));
+}
+
 boolean map::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_map_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 boolean map::is_bijective() const
 {
   auto res = isl_map_is_bijective(get());
   return manage(res);
 }
 
 boolean map::is_disjoint(const isl::map &map2) const
 {
   auto res = isl_map_is_disjoint(get(), map2.get());
   return manage(res);
 }
 
+boolean map::is_disjoint(const isl::union_map &umap2) const
+{
+  return isl::union_map(*this).is_disjoint(umap2);
+}
+
+boolean map::is_disjoint(const isl::basic_map &map2) const
+{
+  return this->is_disjoint(isl::map(map2));
+}
+
 boolean map::is_empty() const
 {
   auto res = isl_map_is_empty(get());
   return manage(res);
 }
 
 boolean map::is_equal(const isl::map &map2) const
 {
   auto res = isl_map_is_equal(get(), map2.get());
   return manage(res);
 }
 
-boolean map::is_identity() const
+boolean map::is_equal(const isl::union_map &umap2) const
 {
-  auto res = isl_map_is_identity(get());
-  return manage(res);
+  return isl::union_map(*this).is_equal(umap2);
 }
 
-boolean map::is_injective() const
+boolean map::is_equal(const isl::basic_map &map2) const
 {
-  auto res = isl_map_is_injective(get());
-  return manage(res);
+  return this->is_equal(isl::map(map2));
 }
 
-boolean map::is_product() const
+boolean map::is_injective() const
 {
-  auto res = isl_map_is_product(get());
+  auto res = isl_map_is_injective(get());
   return manage(res);
 }
 
 boolean map::is_single_valued() const
 {
   auto res = isl_map_is_single_valued(get());
   return manage(res);
 }
 
 boolean map::is_strict_subset(const isl::map &map2) const
 {
   auto res = isl_map_is_strict_subset(get(), map2.get());
   return manage(res);
 }
 
-boolean map::is_subset(const isl::map &map2) const
+boolean map::is_strict_subset(const isl::union_map &umap2) const
 {
-  auto res = isl_map_is_subset(get(), map2.get());
-  return manage(res);
+  return isl::union_map(*this).is_strict_subset(umap2);
 }
 
-int map::is_translation() const
+boolean map::is_strict_subset(const isl::basic_map &map2) const
 {
-  auto res = isl_map_is_translation(get());
-  return res;
+  return this->is_strict_subset(isl::map(map2));
 }
 
-isl::map map::lex_ge(isl::space set_space)
+boolean map::is_subset(const isl::map &map2) const
 {
-  auto res = isl_map_lex_ge(set_space.release());
+  auto res = isl_map_is_subset(get(), map2.get());
   return manage(res);
 }
 
-isl::map map::lex_ge_at(isl::multi_pw_aff mpa) const
+boolean map::is_subset(const isl::union_map &umap2) const
 {
-  auto res = isl_map_lex_ge_at_multi_pw_aff(copy(), mpa.release());
-  return manage(res);
+  return isl::union_map(*this).is_subset(umap2);
 }
 
-isl::map map::lex_ge_first(isl::space space, unsigned int n)
+boolean map::is_subset(const isl::basic_map &map2) const
 {
-  auto res = isl_map_lex_ge_first(space.release(), n);
-  return manage(res);
+  return this->is_subset(isl::map(map2));
 }
 
-isl::map map::lex_ge_map(isl::map map2) const
+boolean map::isa_map() const
 {
-  auto res = isl_map_lex_ge_map(copy(), map2.release());
-  return manage(res);
+  return isl::union_map(*this).isa_map();
 }
 
-isl::map map::lex_gt(isl::space set_space)
+isl::map map::lex_ge(isl::space set_space)
 {
-  auto res = isl_map_lex_gt(set_space.release());
+  auto res = isl_map_lex_ge(set_space.release());
   return manage(res);
 }
 
-isl::map map::lex_gt_at(isl::multi_pw_aff mpa) const
+isl::map map::lex_ge_at(isl::multi_pw_aff mpa) const
 {
-  auto res = isl_map_lex_gt_at_multi_pw_aff(copy(), mpa.release());
+  auto res = isl_map_lex_ge_at_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
-isl::map map::lex_gt_first(isl::space space, unsigned int n)
+isl::map map::lex_gt(isl::space set_space)
 {
-  auto res = isl_map_lex_gt_first(space.release(), n);
+  auto res = isl_map_lex_gt(set_space.release());
   return manage(res);
 }
 
-isl::map map::lex_gt_map(isl::map map2) const
+isl::map map::lex_gt_at(isl::multi_pw_aff mpa) const
 {
-  auto res = isl_map_lex_gt_map(copy(), map2.release());
+  auto res = isl_map_lex_gt_at_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
 isl::map map::lex_le(isl::space set_space)
 {
   auto res = isl_map_lex_le(set_space.release());
   return manage(res);
 }
 
 isl::map map::lex_le_at(isl::multi_pw_aff mpa) const
 {
   auto res = isl_map_lex_le_at_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
-isl::map map::lex_le_first(isl::space space, unsigned int n)
-{
-  auto res = isl_map_lex_le_first(space.release(), n);
-  return manage(res);
-}
-
-isl::map map::lex_le_map(isl::map map2) const
-{
-  auto res = isl_map_lex_le_map(copy(), map2.release());
-  return manage(res);
-}
-
 isl::map map::lex_lt(isl::space set_space)
 {
   auto res = isl_map_lex_lt(set_space.release());
   return manage(res);
 }
 
 isl::map map::lex_lt_at(isl::multi_pw_aff mpa) const
 {
   auto res = isl_map_lex_lt_at_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
-isl::map map::lex_lt_first(isl::space space, unsigned int n)
-{
-  auto res = isl_map_lex_lt_first(space.release(), n);
-  return manage(res);
-}
-
-isl::map map::lex_lt_map(isl::map map2) const
-{
-  auto res = isl_map_lex_lt_map(copy(), map2.release());
-  return manage(res);
-}
-
 isl::map map::lexmax() const
 {
   auto res = isl_map_lexmax(copy());
   return manage(res);
 }
 
 isl::pw_multi_aff map::lexmax_pw_multi_aff() const
 {

 }
 
 isl::map map::lower_bound_si(isl::dim type, unsigned int pos, int value) const
 {
   auto res = isl_map_lower_bound_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
   return manage(res);
 }
 
-isl::map map::lower_bound_val(isl::dim type, unsigned int pos, isl::val value) const
+isl::map_list map::map_list() const
 {
-  auto res = isl_map_lower_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
-  return manage(res);
+  return isl::union_map(*this).map_list();
 }
 
 isl::multi_pw_aff map::max_multi_pw_aff() const
 {
   auto res = isl_map_max_multi_pw_aff(copy());
   return manage(res);
 }
 
 isl::multi_pw_aff map::min_multi_pw_aff() const
 {
   auto res = isl_map_min_multi_pw_aff(copy());
   return manage(res);
 }
 
 isl::map map::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_map_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_size map::n_basic_map() const
+class size map::n_basic_map() const
 {
   auto res = isl_map_n_basic_map(get());
-  return res;
+  return manage(res);
 }
 
-isl::map map::nat_universe(isl::space space)
+isl::map map::order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 {
-  auto res = isl_map_nat_universe(space.release());
+  auto res = isl_map_order_lt(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
   return manage(res);
 }
 
-isl::map map::neg() const
+isl::set map::params() const
 {
-  auto res = isl_map_neg(copy());
-  return manage(res);
+  return isl::union_map(*this).params();
 }
 
-isl::map map::oppose(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::basic_map map::polyhedral_hull() const
 {
-  auto res = isl_map_oppose(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
+  auto res = isl_map_polyhedral_hull(copy());
   return manage(res);
 }
 
-isl::map map::order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::map map::preimage_domain(isl::multi_aff ma) const
 {
-  auto res = isl_map_order_ge(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
+  auto res = isl_map_preimage_domain_multi_aff(copy(), ma.release());
   return manage(res);
 }
 
-isl::map map::order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::map map::preimage_domain(isl::multi_pw_aff mpa) const
 {
-  auto res = isl_map_order_gt(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
+  auto res = isl_map_preimage_domain_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
-isl::map map::order_le(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::map map::preimage_domain(isl::pw_multi_aff pma) const
 {
-  auto res = isl_map_order_le(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
+  auto res = isl_map_preimage_domain_pw_multi_aff(copy(), pma.release());
   return manage(res);
 }
 
-isl::map map::order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+isl::union_map map::preimage_domain(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_map_order_lt(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
-  return manage(res);
+  return isl::union_map(*this).preimage_domain(upma);
 }
 
-isl::set map::params() const
+isl::map map::preimage_range(isl::multi_aff ma) const
 {
-  auto res = isl_map_params(copy());
+  auto res = isl_map_preimage_range_multi_aff(copy(), ma.release());
   return manage(res);
 }
 
-isl::val map::plain_get_val_if_fixed(isl::dim type, unsigned int pos) const
+isl::map map::preimage_range(isl::pw_multi_aff pma) const
 {
-  auto res = isl_map_plain_get_val_if_fixed(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_map_preimage_range_pw_multi_aff(copy(), pma.release());
   return manage(res);
 }
 
-boolean map::plain_is_empty() const
+isl::union_map map::preimage_range(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_map_plain_is_empty(get());
-  return manage(res);
+  return isl::union_map(*this).preimage_range(upma);
 }
 
-boolean map::plain_is_equal(const isl::map &map2) const
+isl::map map::product(isl::map map2) const
 {
-  auto res = isl_map_plain_is_equal(get(), map2.get());
+  auto res = isl_map_product(copy(), map2.release());
   return manage(res);
 }
 
-boolean map::plain_is_injective() const
+isl::union_map map::product(const isl::union_map &umap2) const
 {
-  auto res = isl_map_plain_is_injective(get());
-  return manage(res);
+  return isl::union_map(*this).product(umap2);
 }
 
-boolean map::plain_is_single_valued() const
+isl::map map::product(const isl::basic_map &map2) const
 {
-  auto res = isl_map_plain_is_single_valued(get());
-  return manage(res);
+  return this->product(isl::map(map2));
 }
 
-boolean map::plain_is_universe() const
+isl::map map::project_out(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_map_plain_is_universe(get());
+  auto res = isl_map_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::basic_map map::plain_unshifted_simple_hull() const
+isl::map map::project_out_all_params() const
 {
-  auto res = isl_map_plain_unshifted_simple_hull(copy());
+  auto res = isl_map_project_out_all_params(copy());
   return manage(res);
 }
 
-isl::basic_map map::polyhedral_hull() const
+isl::set map::range() const
 {
-  auto res = isl_map_polyhedral_hull(copy());
+  auto res = isl_map_range(copy());
   return manage(res);
 }
 
-isl::map map::preimage_domain(isl::multi_aff ma) const
+isl::map map::range_factor_domain() const
 {
-  auto res = isl_map_preimage_domain_multi_aff(copy(), ma.release());
+  auto res = isl_map_range_factor_domain(copy());
   return manage(res);
 }
 
-isl::map map::preimage_domain(isl::multi_pw_aff mpa) const
+isl::map map::range_factor_range() const
 {
-  auto res = isl_map_preimage_domain_multi_pw_aff(copy(), mpa.release());
+  auto res = isl_map_range_factor_range(copy());
   return manage(res);
 }
 
-isl::map map::preimage_domain(isl::pw_multi_aff pma) const
+isl::fixed_box map::range_lattice_tile() const
 {
-  auto res = isl_map_preimage_domain_pw_multi_aff(copy(), pma.release());
+  auto res = isl_map_get_range_lattice_tile(get());
   return manage(res);
 }
 
-isl::map map::preimage_range(isl::multi_aff ma) const
+isl::fixed_box map::get_range_lattice_tile() const
 {
-  auto res = isl_map_preimage_range_multi_aff(copy(), ma.release());
-  return manage(res);
+  return range_lattice_tile();
 }
 
-isl::map map::preimage_range(isl::pw_multi_aff pma) const
+isl::map map::range_map() const
 {
-  auto res = isl_map_preimage_range_pw_multi_aff(copy(), pma.release());
+  auto res = isl_map_range_map(copy());
   return manage(res);
 }
 
-isl::map map::product(isl::map map2) const
+isl::map map::range_product(isl::map map2) const
 {
-  auto res = isl_map_product(copy(), map2.release());
+  auto res = isl_map_range_product(copy(), map2.release());
   return manage(res);
 }
 
-isl::map map::project_out(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_map map::range_product(const isl::union_map &umap2) const
 {
-  auto res = isl_map_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::union_map(*this).range_product(umap2);
 }
 
-isl::map map::project_out_all_params() const
+isl::map map::range_product(const isl::basic_map &map2) const
 {
-  auto res = isl_map_project_out_all_params(copy());
-  return manage(res);
+  return this->range_product(isl::map(map2));
 }
 
-isl::set map::range() const
+isl::map map::range_reverse() const
 {
-  auto res = isl_map_range(copy());
+  auto res = isl_map_range_reverse(copy());
   return manage(res);
 }
 
-isl::map map::range_curry() const
+isl::fixed_box map::range_simple_fixed_box_hull() const
 {
-  auto res = isl_map_range_curry(copy());
+  auto res = isl_map_get_range_simple_fixed_box_hull(get());
   return manage(res);
 }
 
-isl::map map::range_factor_domain() const
+isl::fixed_box map::get_range_simple_fixed_box_hull() const
 {
-  auto res = isl_map_range_factor_domain(copy());
-  return manage(res);
+  return range_simple_fixed_box_hull();
 }
 
-isl::map map::range_factor_range() const
+class size map::range_tuple_dim() const
 {
-  auto res = isl_map_range_factor_range(copy());
+  auto res = isl_map_range_tuple_dim(get());
   return manage(res);
 }
 
-boolean map::range_is_wrapping() const
+isl::id map::range_tuple_id() const
 {
-  auto res = isl_map_range_is_wrapping(get());
+  auto res = isl_map_get_range_tuple_id(get());
   return manage(res);
 }
 
-isl::map map::range_map() const
+isl::id map::get_range_tuple_id() const
 {
-  auto res = isl_map_range_map(copy());
-  return manage(res);
+  return range_tuple_id();
 }
 
-isl::map map::range_product(isl::map map2) const
+isl::map map::reverse() const
 {
-  auto res = isl_map_range_product(copy(), map2.release());
+  auto res = isl_map_reverse(copy());
   return manage(res);
 }
 
-isl::map map::range_reverse() const
+isl::basic_map map::sample() const
 {
-  auto res = isl_map_range_reverse(copy());
+  auto res = isl_map_sample(copy());
   return manage(res);
 }
 
-isl_size map::range_tuple_dim() const
+isl::map map::set_domain_tuple(isl::id id) const
 {
-  auto res = isl_map_range_tuple_dim(get());
-  return res;
+  auto res = isl_map_set_domain_tuple_id(copy(), id.release());
+  return manage(res);
 }
 
-isl::map map::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::map map::set_domain_tuple(const std::string &id) const
 {
-  auto res = isl_map_remove_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->set_domain_tuple(isl::id(ctx(), id));
 }
 
-isl::map map::remove_divs() const
+isl::map map::set_range_tuple(isl::id id) const
 {
-  auto res = isl_map_remove_divs(copy());
+  auto res = isl_map_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::map map::remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::map map::set_range_tuple(const std::string &id) const
 {
-  auto res = isl_map_remove_divs_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->set_range_tuple(isl::id(ctx(), id));
 }
 
-isl::map map::remove_redundancies() const
+isl::map map::set_tuple_id(isl::dim type, isl::id id) const
 {
-  auto res = isl_map_remove_redundancies(copy());
+  auto res = isl_map_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
   return manage(res);
 }
 
-isl::map map::remove_unknown_divs() const
+isl::map map::set_tuple_id(isl::dim type, const std::string &id) const
 {
-  auto res = isl_map_remove_unknown_divs(copy());
-  return manage(res);
+  return this->set_tuple_id(type, isl::id(ctx(), id));
 }
 
-isl::map map::reset_tuple_id(isl::dim type) const
+isl::space map::space() const
 {
-  auto res = isl_map_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_map_get_space(get());
   return manage(res);
 }
 
-isl::map map::reset_user() const
+isl::space map::get_space() const
 {
-  auto res = isl_map_reset_user(copy());
-  return manage(res);
+  return space();
 }
 
-isl::map map::reverse() const
+isl::map map::subtract(isl::map map2) const
 {
-  auto res = isl_map_reverse(copy());
+  auto res = isl_map_subtract(copy(), map2.release());
   return manage(res);
 }
 
-isl::basic_map map::sample() const
+isl::union_map map::subtract(const isl::union_map &umap2) const
 {
-  auto res = isl_map_sample(copy());
-  return manage(res);
+  return isl::union_map(*this).subtract(umap2);
 }
 
-isl::map map::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::map map::subtract(const isl::basic_map &map2) const
 {
-  auto res = isl_map_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return this->subtract(isl::map(map2));
 }
 
-isl::map map::set_tuple_id(isl::dim type, isl::id id) const
+isl::union_map map::subtract_domain(const isl::union_set &dom) const
 {
-  auto res = isl_map_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
-  return manage(res);
+  return isl::union_map(*this).subtract_domain(dom);
 }
 
-isl::map map::set_tuple_name(isl::dim type, const std::string &s) const
+isl::union_map map::subtract_range(const isl::union_set &dom) const
 {
-  auto res = isl_map_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
-  return manage(res);
+  return isl::union_map(*this).subtract_range(dom);
 }
 
-isl::basic_map map::simple_hull() const
+isl::map map::sum(isl::map map2) const
 {
-  auto res = isl_map_simple_hull(copy());
+  auto res = isl_map_sum(copy(), map2.release());
   return manage(res);
 }
 
-isl::map map::subtract(isl::map map2) const
+isl::map_list map::to_list() const
 {
-  auto res = isl_map_subtract(copy(), map2.release());
+  auto res = isl_map_to_list(copy());
   return manage(res);
 }
 
-isl::map map::subtract_domain(isl::set dom) const
+isl::union_map map::to_union_map() const
 {
-  auto res = isl_map_subtract_domain(copy(), dom.release());
+  auto res = isl_map_to_union_map(copy());
   return manage(res);
 }
 
-isl::map map::subtract_range(isl::set dom) const
+isl::id map::tuple_id(isl::dim type) const
 {
-  auto res = isl_map_subtract_range(copy(), dom.release());
+  auto res = isl_map_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::map map::sum(isl::map map2) const
+isl::id map::get_tuple_id(isl::dim type) const
 {
-  auto res = isl_map_sum(copy(), map2.release());
-  return manage(res);
+  return tuple_id(type);
 }
 
 isl::map map::uncurry() const
 {
   auto res = isl_map_uncurry(copy());
   return manage(res);
 }
 
 isl::map map::unite(isl::map map2) const
 {
   auto res = isl_map_union(copy(), map2.release());
   return manage(res);
 }
 
+isl::union_map map::unite(const isl::union_map &umap2) const
+{
+  return isl::union_map(*this).unite(umap2);
+}
+
+isl::map map::unite(const isl::basic_map &map2) const
+{
+  return this->unite(isl::map(map2));
+}
+
 isl::map map::universe(isl::space space)
 {
   auto res = isl_map_universe(space.release());
   return manage(res);
 }
 
 isl::basic_map map::unshifted_simple_hull() const
 {
   auto res = isl_map_unshifted_simple_hull(copy());
   return manage(res);
 }
 
-isl::basic_map map::unshifted_simple_hull_from_map_list(isl::map_list list) const
-{
-  auto res = isl_map_unshifted_simple_hull_from_map_list(copy(), list.release());
-  return manage(res);
-}
-
 isl::map map::upper_bound(isl::multi_pw_aff upper) const
 {
   auto res = isl_map_upper_bound_multi_pw_aff(copy(), upper.release());
   return manage(res);
 }
 
 isl::map map::upper_bound_si(isl::dim type, unsigned int pos, int value) const
 {
   auto res = isl_map_upper_bound_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
   return manage(res);
 }
 
-isl::map map::upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const
-{
-  auto res = isl_map_upper_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
-  return manage(res);
-}
-
 isl::set map::wrap() const
 {
   auto res = isl_map_wrap(copy());
   return manage(res);
 }
 
 isl::map map::zip() const
 {
   auto res = isl_map_zip(copy());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const map &obj)
+{
+  char *str = isl_map_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::map_list
 map_list manage(__isl_take isl_map_list *ptr) {
   return map_list(ptr);
 }
 map_list manage_copy(__isl_keep isl_map_list *ptr) {
   ptr = isl_map_list_copy(ptr);
   return map_list(ptr);
 }
 
 map_list::map_list()
     : ptr(nullptr) {}
 
 map_list::map_list(const map_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 map_list::map_list(__isl_take isl_map_list *ptr)
     : ptr(ptr) {}
 
+map_list::map_list(isl::ctx ctx, int n)
+{
+  auto res = isl_map_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+map_list::map_list(isl::map el)
+{
+  auto res = isl_map_list_from_map(el.release());
+  ptr = res;
+}
+
+map_list::map_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_map_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 map_list &map_list::operator=(map_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 map_list::~map_list() {
   if (ptr)
__isl_give isl_map_list *map_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool map_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx map_list::ctx() const {
   return isl::ctx(isl_map_list_get_ctx(ptr));
 }
 
-void map_list::dump() const {
-  isl_map_list_dump(get());
-}
-
-
 isl::map_list map_list::add(isl::map el) const
 {
   auto res = isl_map_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::map_list map_list::alloc(isl::ctx ctx, int n)
+isl::map map_list::at(int index) const
 {
-  auto res = isl_map_list_alloc(ctx.release(), n);
+  auto res = isl_map_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::map map_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::map_list map_list::clear() const
 {
   auto res = isl_map_list_clear(copy());
   return manage(res);
 }
 
 isl::map_list map_list::concat(isl::map_list list2) const
 {
   auto res = isl_map_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::map_list map_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_map_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat map_list::foreach(const std::function<stat(map)> &fn) const
+stat map_list::foreach(const std::function<stat(isl::map)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(map)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_map_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::map_list map_list::from_map(isl::map el)
+isl::map_list map_list::insert(unsigned int pos, isl::map el) const
 {
-  auto res = isl_map_list_from_map(el.release());
+  auto res = isl_map_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::map map_list::get_at(int index) const
+class size map_list::size() const
 {
-  auto res = isl_map_list_get_at(get(), index);
+  auto res = isl_map_list_size(get());
   return manage(res);
 }
 
-isl::map map_list::get_map(int index) const
+inline std::ostream &operator<<(std::ostream &os, const map_list &obj)
 {
-  auto res = isl_map_list_get_map(get(), index);
-  return manage(res);
+  char *str = isl_map_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-isl::map_list map_list::insert(unsigned int pos, isl::map el) const
-{
-  auto res = isl_map_list_insert(copy(), pos, el.release());
-  return manage(res);
+// implementations for isl::multi_aff
+multi_aff manage(__isl_take isl_multi_aff *ptr) {
+  return multi_aff(ptr);
 }
-
-isl_size map_list::n_map() const
-{
-  auto res = isl_map_list_n_map(get());
-  return res;
+multi_aff manage_copy(__isl_keep isl_multi_aff *ptr) {
+  ptr = isl_multi_aff_copy(ptr);
+  return multi_aff(ptr);
 }
 
-isl::map_list map_list::reverse() const
-{
-  auto res = isl_map_list_reverse(copy());
-  return manage(res);
-}
+multi_aff::multi_aff()
+    : ptr(nullptr) {}
 
-isl::map_list map_list::set_map(int index, isl::map el) const
+multi_aff::multi_aff(const multi_aff &obj)
+    : ptr(nullptr)
 {
-  auto res = isl_map_list_set_map(copy(), index, el.release());
-  return manage(res);
+  ptr = obj.copy();
 }
 
-isl_size map_list::size() const
-{
-  auto res = isl_map_list_size(get());
-  return res;
-}
+multi_aff::multi_aff(__isl_take isl_multi_aff *ptr)
+    : ptr(ptr) {}
 
-isl::map_list map_list::swap(unsigned int pos1, unsigned int pos2) const
+multi_aff::multi_aff(isl::aff aff)
 {
-  auto res = isl_map_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  auto res = isl_multi_aff_from_aff(aff.release());
+  ptr = res;
 }
 
-// implementations for isl::mat
-mat manage(__isl_take isl_mat *ptr) {
-  return mat(ptr);
-}
-mat manage_copy(__isl_keep isl_mat *ptr) {
-  ptr = isl_mat_copy(ptr);
-  return mat(ptr);
+multi_aff::multi_aff(isl::space space, isl::aff_list list)
+{
+  auto res = isl_multi_aff_from_aff_list(space.release(), list.release());
+  ptr = res;
 }
 
-mat::mat()
-    : ptr(nullptr) {}
-
-mat::mat(const mat &obj)
-    : ptr(nullptr)
+multi_aff::multi_aff(isl::ctx ctx, const std::string &str)
 {
-  ptr = obj.copy();
+  auto res = isl_multi_aff_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
 }
 
-
-mat::mat(__isl_take isl_mat *ptr)
-    : ptr(ptr) {}
-
-
-mat &mat::operator=(mat obj) {
+multi_aff &multi_aff::operator=(multi_aff obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
-mat::~mat() {
+multi_aff::~multi_aff() {
   if (ptr)
-    isl_mat_free(ptr);
+    isl_multi_aff_free(ptr);
 }
 
-__isl_give isl_mat *mat::copy() const & {
-  return isl_mat_copy(ptr);
+__isl_give isl_multi_aff *multi_aff::copy() const & {
+  return isl_multi_aff_copy(ptr);
 }
 
-__isl_keep isl_mat *mat::get() const {
+__isl_keep isl_multi_aff *multi_aff::get() const {
   return ptr;
 }
 
-__isl_give isl_mat *mat::release() {
-  isl_mat *tmp = ptr;
+__isl_give isl_multi_aff *multi_aff::release() {
+  isl_multi_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
-bool mat::is_null() const {
+bool multi_aff::is_null() const {
   return ptr == nullptr;
 }
 
+isl::ctx multi_aff::ctx() const {
+  return isl::ctx(isl_multi_aff_get_ctx(ptr));
+}
 
-isl::ctx mat::ctx() const {
-  return isl::ctx(isl_mat_get_ctx(ptr));
+isl::multi_aff multi_aff::add(isl::multi_aff multi2) const
+{
+  auto res = isl_multi_aff_add(copy(), multi2.release());
+  return manage(res);
 }
 
-void mat::dump() const {
-  isl_mat_dump(get());
+isl::multi_pw_aff multi_aff::add(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_multi_aff(*this).add(multi2);
 }
 
+isl::multi_union_pw_aff multi_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::pw_multi_aff(*this).add(multi2);
+}
 
-isl::mat mat::add_rows(unsigned int n) const
+isl::pw_multi_aff multi_aff::add(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_mat_add_rows(copy(), n);
-  return manage(res);
+  return isl::pw_multi_aff(*this).add(pma2);
 }
 
-isl::mat mat::add_zero_cols(unsigned int n) const
+isl::union_pw_multi_aff multi_aff::add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_mat_add_zero_cols(copy(), n);
-  return manage(res);
+  return isl::pw_multi_aff(*this).add(upma2);
 }
 
-isl::mat mat::add_zero_rows(unsigned int n) const
+isl::multi_aff multi_aff::add(const isl::aff &multi2) const
 {
-  auto res = isl_mat_add_zero_rows(copy(), n);
-  return manage(res);
+  return this->add(isl::multi_aff(multi2));
 }
 
-isl::mat mat::aff_direct_sum(isl::mat right) const
+isl::multi_aff multi_aff::add_constant(isl::multi_val mv) const
 {
-  auto res = isl_mat_aff_direct_sum(copy(), right.release());
+  auto res = isl_multi_aff_add_constant_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-isl::mat mat::alloc(isl::ctx ctx, unsigned int n_row, unsigned int n_col)
+isl::multi_aff multi_aff::add_constant(isl::val v) const
 {
-  auto res = isl_mat_alloc(ctx.release(), n_row, n_col);
+  auto res = isl_multi_aff_add_constant_val(copy(), v.release());
   return manage(res);
 }
 
-isl_size mat::cols() const
+isl::multi_aff multi_aff::add_constant(long v) const
 {
-  auto res = isl_mat_cols(get());
-  return res;
+  return this->add_constant(isl::val(ctx(), v));
 }
 
-isl::mat mat::concat(isl::mat bot) const
+isl::union_pw_multi_aff multi_aff::add_pw_multi_aff(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_mat_concat(copy(), bot.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).add_pw_multi_aff(pma);
 }
 
-isl::mat mat::diagonal(isl::mat mat2) const
+isl::union_pw_multi_aff multi_aff::apply(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_mat_diagonal(copy(), mat2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).apply(upma2);
 }
 
-isl::mat mat::drop_cols(unsigned int col, unsigned int n) const
+isl::map multi_aff::as_map() const
 {
-  auto res = isl_mat_drop_cols(copy(), col, n);
+  auto res = isl_multi_aff_as_map(copy());
   return manage(res);
 }
 
-isl::mat mat::drop_rows(unsigned int row, unsigned int n) const
+isl::multi_aff multi_aff::as_multi_aff() const
 {
-  auto res = isl_mat_drop_rows(copy(), row, n);
-  return manage(res);
+  return isl::pw_multi_aff(*this).as_multi_aff();
 }
 
-isl::mat mat::from_row_vec(isl::vec vec)
+isl::multi_union_pw_aff multi_aff::as_multi_union_pw_aff() const
 {
-  auto res = isl_mat_from_row_vec(vec.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).as_multi_union_pw_aff();
 }
 
-isl::val mat::get_element_val(int row, int col) const
+isl::pw_multi_aff multi_aff::as_pw_multi_aff() const
 {
-  auto res = isl_mat_get_element_val(get(), row, col);
-  return manage(res);
+  return isl::pw_multi_aff(*this).as_pw_multi_aff();
 }
 
-boolean mat::has_linearly_independent_rows(const isl::mat &mat2) const
+isl::set multi_aff::as_set() const
 {
-  auto res = isl_mat_has_linearly_independent_rows(get(), mat2.get());
+  auto res = isl_multi_aff_as_set(copy());
   return manage(res);
 }
 
-int mat::initial_non_zero_cols() const
+isl::union_map multi_aff::as_union_map() const
 {
-  auto res = isl_mat_initial_non_zero_cols(get());
-  return res;
+  return isl::pw_multi_aff(*this).as_union_map();
 }
 
-isl::mat mat::insert_cols(unsigned int col, unsigned int n) const
+isl::aff multi_aff::at(int pos) const
 {
-  auto res = isl_mat_insert_cols(copy(), col, n);
+  auto res = isl_multi_aff_get_at(get(), pos);
   return manage(res);
 }
 
-isl::mat mat::insert_rows(unsigned int row, unsigned int n) const
+isl::aff multi_aff::get_at(int pos) const
 {
-  auto res = isl_mat_insert_rows(copy(), row, n);
-  return manage(res);
+  return at(pos);
 }
 
-isl::mat mat::insert_zero_cols(unsigned int first, unsigned int n) const
+isl::basic_set multi_aff::bind(isl::multi_id tuple) const
 {
-  auto res = isl_mat_insert_zero_cols(copy(), first, n);
+  auto res = isl_multi_aff_bind(copy(), tuple.release());
   return manage(res);
 }
 
-isl::mat mat::insert_zero_rows(unsigned int row, unsigned int n) const
+isl::multi_aff multi_aff::bind_domain(isl::multi_id tuple) const
 {
-  auto res = isl_mat_insert_zero_rows(copy(), row, n);
+  auto res = isl_multi_aff_bind_domain(copy(), tuple.release());
   return manage(res);
 }
 
-isl::mat mat::inverse_product(isl::mat right) const
+isl::multi_aff multi_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
 {
-  auto res = isl_mat_inverse_product(copy(), right.release());
+  auto res = isl_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
   return manage(res);
 }
 
-boolean mat::is_equal(const isl::mat &mat2) const
+isl::pw_multi_aff multi_aff::coalesce() const
 {
-  auto res = isl_mat_is_equal(get(), mat2.get());
-  return manage(res);
+  return isl::pw_multi_aff(*this).coalesce();
 }
 
-isl::mat mat::lin_to_aff() const
+isl::multi_val multi_aff::constant_multi_val() const
 {
-  auto res = isl_mat_lin_to_aff(copy());
+  auto res = isl_multi_aff_get_constant_multi_val(get());
   return manage(res);
 }
 
-isl::mat mat::move_cols(unsigned int dst_col, unsigned int src_col, unsigned int n) const
+isl::multi_val multi_aff::get_constant_multi_val() const
 {
-  auto res = isl_mat_move_cols(copy(), dst_col, src_col, n);
-  return manage(res);
+  return constant_multi_val();
 }
 
-isl::mat mat::normalize() const
+class size multi_aff::dim(isl::dim type) const
 {
-  auto res = isl_mat_normalize(copy());
+  auto res = isl_multi_aff_dim(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::mat mat::normalize_row(int row) const
+isl::set multi_aff::domain() const
 {
-  auto res = isl_mat_normalize_row(copy(), row);
-  return manage(res);
+  return isl::pw_multi_aff(*this).domain();
 }
 
-isl::mat mat::product(isl::mat right) const
+isl::multi_aff multi_aff::domain_map(isl::space space)
 {
-  auto res = isl_mat_product(copy(), right.release());
+  auto res = isl_multi_aff_domain_map(space.release());
   return manage(res);
 }
 
-isl_size mat::rank() const
+isl::pw_multi_aff multi_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_mat_rank(get());
-  return res;
+  return isl::pw_multi_aff(*this).drop_dims(type, first, n);
 }
 
-isl::mat mat::right_inverse() const
+isl::pw_multi_aff multi_aff::extract_pw_multi_aff(const isl::space &space) const
 {
-  auto res = isl_mat_right_inverse(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).extract_pw_multi_aff(space);
 }
 
-isl::mat mat::right_kernel() const
+isl::multi_aff multi_aff::flat_range_product(isl::multi_aff multi2) const
 {
-  auto res = isl_mat_right_kernel(copy());
+  auto res = isl_multi_aff_flat_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-isl::mat mat::row_basis() const
+isl::multi_pw_aff multi_aff::flat_range_product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_mat_row_basis(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).flat_range_product(multi2);
 }
 
-isl::mat mat::row_basis_extension(isl::mat mat2) const
+isl::multi_union_pw_aff multi_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_mat_row_basis_extension(copy(), mat2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).flat_range_product(multi2);
 }
 
-isl_size mat::rows() const
+isl::pw_multi_aff multi_aff::flat_range_product(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_mat_rows(get());
-  return res;
+  return isl::pw_multi_aff(*this).flat_range_product(pma2);
 }
 
-isl::mat mat::set_element_si(int row, int col, int v) const
+isl::union_pw_multi_aff multi_aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_mat_set_element_si(copy(), row, col, v);
-  return manage(res);
+  return isl::pw_multi_aff(*this).flat_range_product(upma2);
 }
 
-isl::mat mat::set_element_val(int row, int col, isl::val v) const
+isl::multi_aff multi_aff::flat_range_product(const isl::aff &multi2) const
 {
-  auto res = isl_mat_set_element_val(copy(), row, col, v.release());
-  return manage(res);
+  return this->flat_range_product(isl::multi_aff(multi2));
 }
 
-isl::mat mat::swap_cols(unsigned int i, unsigned int j) const
+isl::multi_aff multi_aff::floor() const
 {
-  auto res = isl_mat_swap_cols(copy(), i, j);
+  auto res = isl_multi_aff_floor(copy());
   return manage(res);
 }
 
-isl::mat mat::swap_rows(unsigned int i, unsigned int j) const
+stat multi_aff::foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const
 {
-  auto res = isl_mat_swap_rows(copy(), i, j);
-  return manage(res);
+  return isl::pw_multi_aff(*this).foreach_piece(fn);
 }
 
-isl::mat mat::transpose() const
+isl::multi_aff multi_aff::gist(isl::set context) const
 {
-  auto res = isl_mat_transpose(copy());
+  auto res = isl_multi_aff_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::mat mat::unimodular_complete(int row) const
+isl::union_pw_multi_aff multi_aff::gist(const isl::union_set &context) const
 {
-  auto res = isl_mat_unimodular_complete(copy(), row);
-  return manage(res);
+  return isl::pw_multi_aff(*this).gist(context);
 }
 
-isl::mat mat::vec_concat(isl::vec bot) const
+isl::multi_aff multi_aff::gist(const isl::basic_set &context) const
 {
-  auto res = isl_mat_vec_concat(copy(), bot.release());
-  return manage(res);
+  return this->gist(isl::set(context));
+}
+
+isl::multi_aff multi_aff::gist(const isl::point &context) const
+{
+  return this->gist(isl::set(context));
 }
 
-isl::vec mat::vec_inverse_product(isl::vec vec) const
+boolean multi_aff::has_range_tuple_id() const
 {
-  auto res = isl_mat_vec_inverse_product(copy(), vec.release());
+  auto res = isl_multi_aff_has_range_tuple_id(get());
   return manage(res);
 }
 
-isl::vec mat::vec_product(isl::vec vec) const
+isl::multi_aff multi_aff::identity(isl::space space)
 {
-  auto res = isl_mat_vec_product(copy(), vec.release());
+  auto res = isl_multi_aff_identity(space.release());
   return manage(res);
 }
 
-// implementations for isl::multi_aff
-multi_aff manage(__isl_take isl_multi_aff *ptr) {
-  return multi_aff(ptr);
+isl::multi_aff multi_aff::identity() const
+{
+  auto res = isl_multi_aff_identity_multi_aff(copy());
+  return manage(res);
 }
-multi_aff manage_copy(__isl_keep isl_multi_aff *ptr) {
-  ptr = isl_multi_aff_copy(ptr);
-  return multi_aff(ptr);
+
+isl::multi_aff multi_aff::identity_on_domain(isl::space space)
+{
+  auto res = isl_multi_aff_identity_on_domain_space(space.release());
+  return manage(res);
 }
 
-multi_aff::multi_aff()
-    : ptr(nullptr) {}
+isl::multi_aff multi_aff::insert_domain(isl::space domain) const
+{
+  auto res = isl_multi_aff_insert_domain(copy(), domain.release());
+  return manage(res);
+}
 
-multi_aff::multi_aff(const multi_aff &obj)
-    : ptr(nullptr)
+isl::pw_multi_aff multi_aff::intersect_domain(const isl::set &set) const
 {
-  ptr = obj.copy();
+  return isl::pw_multi_aff(*this).intersect_domain(set);
 }
 
+isl::union_pw_multi_aff multi_aff::intersect_domain(const isl::space &space) const
+{
+  return isl::pw_multi_aff(*this).intersect_domain(space);
+}
 
-multi_aff::multi_aff(__isl_take isl_multi_aff *ptr)
-    : ptr(ptr) {}
+isl::union_pw_multi_aff multi_aff::intersect_domain(const isl::union_set &uset) const
+{
+  return isl::pw_multi_aff(*this).intersect_domain(uset);
+}
 
-multi_aff::multi_aff(isl::aff aff)
+isl::union_pw_multi_aff multi_aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
 {
-  auto res = isl_multi_aff_from_aff(aff.release());
-  ptr = res;
+  return isl::pw_multi_aff(*this).intersect_domain_wrapped_domain(uset);
 }
-multi_aff::multi_aff(isl::space space, isl::aff_list list)
+
+isl::union_pw_multi_aff multi_aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
 {
-  auto res = isl_multi_aff_from_aff_list(space.release(), list.release());
-  ptr = res;
+  return isl::pw_multi_aff(*this).intersect_domain_wrapped_range(uset);
 }
-multi_aff::multi_aff(isl::ctx ctx, const std::string &str)
+
+isl::pw_multi_aff multi_aff::intersect_params(const isl::set &set) const
 {
-  auto res = isl_multi_aff_read_from_str(ctx.release(), str.c_str());
-  ptr = res;
+  return isl::pw_multi_aff(*this).intersect_params(set);
 }
 
-multi_aff &multi_aff::operator=(multi_aff obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+boolean multi_aff::involves_locals() const
+{
+  auto res = isl_multi_aff_involves_locals(get());
+  return manage(res);
 }
 
-multi_aff::~multi_aff() {
-  if (ptr)
-    isl_multi_aff_free(ptr);
+boolean multi_aff::involves_nan() const
+{
+  auto res = isl_multi_aff_involves_nan(get());
+  return manage(res);
 }
 
-__isl_give isl_multi_aff *multi_aff::copy() const & {
-  return isl_multi_aff_copy(ptr);
+boolean multi_aff::involves_param(const isl::id &id) const
+{
+  return isl::pw_multi_aff(*this).involves_param(id);
 }
 
-__isl_keep isl_multi_aff *multi_aff::get() const {
-  return ptr;
+boolean multi_aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::id(ctx(), id));
 }
 
-__isl_give isl_multi_aff *multi_aff::release() {
-  isl_multi_aff *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+boolean multi_aff::involves_param(const isl::id_list &list) const
+{
+  return isl::pw_multi_aff(*this).involves_param(list);
 }
 
-bool multi_aff::is_null() const {
-  return ptr == nullptr;
+boolean multi_aff::isa_multi_aff() const
+{
+  return isl::pw_multi_aff(*this).isa_multi_aff();
 }
 
+boolean multi_aff::isa_pw_multi_aff() const
+{
+  return isl::pw_multi_aff(*this).isa_pw_multi_aff();
+}
 
-isl::ctx multi_aff::ctx() const {
-  return isl::ctx(isl_multi_aff_get_ctx(ptr));
+isl::aff_list multi_aff::list() const
+{
+  auto res = isl_multi_aff_get_list(get());
+  return manage(res);
 }
 
-void multi_aff::dump() const {
-  isl_multi_aff_dump(get());
+isl::aff_list multi_aff::get_list() const
+{
+  return list();
 }
 
+isl::multi_pw_aff multi_aff::max(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_multi_aff(*this).max(multi2);
+}
 
-isl::multi_aff multi_aff::add(isl::multi_aff multi2) const
+isl::multi_val multi_aff::max_multi_val() const
 {
-  auto res = isl_multi_aff_add(copy(), multi2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).max_multi_val();
 }
 
-isl::multi_aff multi_aff::add_constant(isl::multi_val mv) const
+isl::multi_pw_aff multi_aff::min(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_add_constant_multi_val(copy(), mv.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).min(multi2);
 }
 
-isl::multi_aff multi_aff::add_constant(isl::val v) const
+isl::multi_val multi_aff::min_multi_val() const
 {
-  auto res = isl_multi_aff_add_constant_val(copy(), v.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).min_multi_val();
 }
 
-isl::multi_aff multi_aff::add_dims(isl::dim type, unsigned int n) const
+isl::multi_aff multi_aff::multi_val_on_domain(isl::space space, isl::multi_val mv)
 {
-  auto res = isl_multi_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
+  auto res = isl_multi_aff_multi_val_on_domain_space(space.release(), mv.release());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::align_params(isl::space model) const
+class size multi_aff::n_piece() const
 {
-  auto res = isl_multi_aff_align_params(copy(), model.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).n_piece();
 }
 
-isl::basic_set multi_aff::bind(isl::multi_id tuple) const
+isl::multi_aff multi_aff::neg() const
 {
-  auto res = isl_multi_aff_bind(copy(), tuple.release());
+  auto res = isl_multi_aff_neg(copy());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::bind_domain(isl::multi_id tuple) const
+boolean multi_aff::plain_is_empty() const
 {
-  auto res = isl_multi_aff_bind_domain(copy(), tuple.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).plain_is_empty();
 }
 
-isl::multi_aff multi_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+boolean multi_aff::plain_is_equal(const isl::multi_aff &multi2) const
 {
-  auto res = isl_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  auto res = isl_multi_aff_plain_is_equal(get(), multi2.get());
   return manage(res);
 }
 
-isl_size multi_aff::dim(isl::dim type) const
+boolean multi_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::pw_multi_aff(*this).plain_is_equal(multi2);
 }
 
-isl::multi_aff multi_aff::domain_map(isl::space space)
+boolean multi_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_domain_map(space.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).plain_is_equal(multi2);
 }
 
-isl::multi_aff multi_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+boolean multi_aff::plain_is_equal(const isl::aff &multi2) const
 {
-  auto res = isl_multi_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->plain_is_equal(isl::multi_aff(multi2));
 }
 
-isl::multi_aff multi_aff::factor_range() const
+isl::pw_multi_aff multi_aff::preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_multi_aff_factor_range(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).preimage_domain_wrapped_domain(pma2);
 }
 
-int multi_aff::find_dim_by_id(isl::dim type, const isl::id &id) const
+isl::union_pw_multi_aff multi_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_multi_aff_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
-  return res;
+  return isl::pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
 }
 
-int multi_aff::find_dim_by_name(isl::dim type, const std::string &name) const
+isl::multi_aff multi_aff::product(isl::multi_aff multi2) const
 {
-  auto res = isl_multi_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  auto res = isl_multi_aff_product(copy(), multi2.release());
+  return manage(res);
 }
 
-isl::multi_aff multi_aff::flat_range_product(isl::multi_aff multi2) const
+isl::multi_pw_aff multi_aff::product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_flat_range_product(copy(), multi2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).product(multi2);
 }
 
-isl::multi_aff multi_aff::flatten_domain() const
+isl::pw_multi_aff multi_aff::product(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_multi_aff_flatten_domain(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).product(pma2);
 }
 
-isl::multi_aff multi_aff::flatten_range() const
+isl::multi_aff multi_aff::product(const isl::aff &multi2) const
 {
-  auto res = isl_multi_aff_flatten_range(copy());
-  return manage(res);
+  return this->product(isl::multi_aff(multi2));
 }
 
-isl::multi_aff multi_aff::floor() const
+isl::multi_aff multi_aff::pullback(isl::multi_aff ma2) const
 {
-  auto res = isl_multi_aff_floor(copy());
+  auto res = isl_multi_aff_pullback_multi_aff(copy(), ma2.release());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::from_range() const
+isl::multi_pw_aff multi_aff::pullback(const isl::multi_pw_aff &mpa2) const
 {
-  auto res = isl_multi_aff_from_range(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).pullback(mpa2);
 }
 
-isl::aff multi_aff::get_aff(int pos) const
+isl::pw_multi_aff multi_aff::pullback(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_multi_aff_get_aff(get(), pos);
-  return manage(res);
+  return isl::pw_multi_aff(*this).pullback(pma2);
 }
 
-isl::aff multi_aff::get_at(int pos) const
+isl::union_pw_multi_aff multi_aff::pullback(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_multi_aff_get_at(get(), pos);
-  return manage(res);
+  return isl::pw_multi_aff(*this).pullback(upma2);
 }
 
-isl::multi_val multi_aff::get_constant_multi_val() const
+isl::multi_aff multi_aff::pullback(const isl::aff &ma2) const
 {
-  auto res = isl_multi_aff_get_constant_multi_val(get());
-  return manage(res);
+  return this->pullback(isl::multi_aff(ma2));
 }
 
-isl::id multi_aff::get_dim_id(isl::dim type, unsigned int pos) const
+isl::pw_multi_aff_list multi_aff::pw_multi_aff_list() const
 {
-  auto res = isl_multi_aff_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::pw_multi_aff(*this).pw_multi_aff_list();
 }
 
-isl::space multi_aff::get_domain_space() const
+isl::pw_multi_aff multi_aff::range_factor_domain() const
 {
-  auto res = isl_multi_aff_get_domain_space(get());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_factor_domain();
 }
 
-isl::aff_list multi_aff::get_list() const
+isl::pw_multi_aff multi_aff::range_factor_range() const
 {
-  auto res = isl_multi_aff_get_list(get());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_factor_range();
 }
 
-isl::space multi_aff::get_space() const
+isl::multi_aff multi_aff::range_map(isl::space space)
 {
-  auto res = isl_multi_aff_get_space(get());
+  auto res = isl_multi_aff_range_map(space.release());
   return manage(res);
 }
 
-isl::id multi_aff::get_tuple_id(isl::dim type) const
+isl::multi_aff multi_aff::range_product(isl::multi_aff multi2) const
 {
-  auto res = isl_multi_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_multi_aff_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-std::string multi_aff::get_tuple_name(isl::dim type) const
+isl::multi_pw_aff multi_aff::range_product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
+  return isl::pw_multi_aff(*this).range_product(multi2);
 }
 
-isl::multi_aff multi_aff::gist(isl::set context) const
+isl::multi_union_pw_aff multi_aff::range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_gist(copy(), context.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_product(multi2);
 }
 
-isl::multi_aff multi_aff::gist_params(isl::set context) const
+isl::pw_multi_aff multi_aff::range_product(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_multi_aff_gist_params(copy(), context.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_product(pma2);
 }
 
-boolean multi_aff::has_tuple_id(isl::dim type) const
+isl::union_pw_multi_aff multi_aff::range_product(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_multi_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_product(upma2);
 }
 
-isl::multi_aff multi_aff::identity(isl::space space)
+isl::multi_aff multi_aff::range_product(const isl::aff &multi2) const
 {
-  auto res = isl_multi_aff_identity(space.release());
-  return manage(res);
+  return this->range_product(isl::multi_aff(multi2));
 }
 
-isl::multi_aff multi_aff::identity() const
+isl::id multi_aff::range_tuple_id() const
 {
-  auto res = isl_multi_aff_identity_multi_aff(copy());
+  auto res = isl_multi_aff_get_range_tuple_id(get());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::identity_on_domain(isl::space space)
+isl::id multi_aff::get_range_tuple_id() const
 {
-  auto res = isl_multi_aff_identity_on_domain_space(space.release());
-  return manage(res);
+  return range_tuple_id();
 }
 
-isl::multi_aff multi_aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::multi_aff multi_aff::reset_range_tuple_id() const
 {
-  auto res = isl_multi_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_multi_aff_reset_range_tuple_id(copy());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::insert_domain(isl::space domain) const
+isl::multi_aff multi_aff::reset_tuple_id(isl::dim type) const
 {
-  auto res = isl_multi_aff_insert_domain(copy(), domain.release());
+  auto res = isl_multi_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean multi_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::multi_aff multi_aff::scale(isl::multi_val mv) const
 {
-  auto res = isl_multi_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_multi_aff_scale_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-boolean multi_aff::involves_locals() const
+isl::multi_aff multi_aff::scale(isl::val v) const
 {
-  auto res = isl_multi_aff_involves_locals(get());
+  auto res = isl_multi_aff_scale_val(copy(), v.release());
   return manage(res);
 }
 
-boolean multi_aff::involves_nan() const
+isl::multi_aff multi_aff::scale(long v) const
 {
-  auto res = isl_multi_aff_involves_nan(get());
-  return manage(res);
+  return this->scale(isl::val(ctx(), v));
 }
 
-isl::set multi_aff::lex_ge_set(isl::multi_aff ma2) const
+isl::multi_aff multi_aff::scale_down(isl::multi_val mv) const
 {
-  auto res = isl_multi_aff_lex_ge_set(copy(), ma2.release());
+  auto res = isl_multi_aff_scale_down_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-isl::set multi_aff::lex_gt_set(isl::multi_aff ma2) const
+isl::multi_aff multi_aff::scale_down(isl::val v) const
 {
-  auto res = isl_multi_aff_lex_gt_set(copy(), ma2.release());
+  auto res = isl_multi_aff_scale_down_val(copy(), v.release());
   return manage(res);
 }
 
-isl::set multi_aff::lex_le_set(isl::multi_aff ma2) const
+isl::multi_aff multi_aff::scale_down(long v) const
 {
-  auto res = isl_multi_aff_lex_le_set(copy(), ma2.release());
-  return manage(res);
+  return this->scale_down(isl::val(ctx(), v));
 }
 
-isl::set multi_aff::lex_lt_set(isl::multi_aff ma2) const
+isl::multi_aff multi_aff::set_aff(int pos, isl::aff el) const
 {
-  auto res = isl_multi_aff_lex_lt_set(copy(), ma2.release());
+  auto res = isl_multi_aff_set_aff(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::mod_multi_val(isl::multi_val mv) const
+isl::multi_aff multi_aff::set_at(int pos, isl::aff el) const
 {
-  auto res = isl_multi_aff_mod_multi_val(copy(), mv.release());
+  auto res = isl_multi_aff_set_at(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::multi_pw_aff multi_aff::set_at(int pos, const isl::pw_aff &el) const
 {
-  auto res = isl_multi_aff_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);
+  return isl::pw_multi_aff(*this).set_at(pos, el);
 }
 
-isl::multi_aff multi_aff::multi_val_on_space(isl::space space, isl::multi_val mv)
+isl::multi_union_pw_aff multi_aff::set_at(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_multi_aff_multi_val_on_space(space.release(), mv.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).set_at(pos, el);
 }
 
-isl::multi_aff multi_aff::neg() const
+isl::multi_pw_aff multi_aff::set_pw_aff(int pos, const isl::pw_aff &el) const
 {
-  auto res = isl_multi_aff_neg(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).set_pw_aff(pos, el);
 }
 
-int multi_aff::plain_cmp(const isl::multi_aff &multi2) const
+isl::pw_multi_aff multi_aff::set_pw_aff(unsigned int pos, const isl::pw_aff &pa) const
 {
-  auto res = isl_multi_aff_plain_cmp(get(), multi2.get());
-  return res;
+  return isl::pw_multi_aff(*this).set_pw_aff(pos, pa);
 }
 
-boolean multi_aff::plain_is_equal(const isl::multi_aff &multi2) const
+isl::multi_aff multi_aff::set_range_tuple(isl::id id) const
 {
-  auto res = isl_multi_aff_plain_is_equal(get(), multi2.get());
+  auto res = isl_multi_aff_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::product(isl::multi_aff multi2) const
+isl::multi_aff multi_aff::set_range_tuple(const std::string &id) const
 {
-  auto res = isl_multi_aff_product(copy(), multi2.release());
-  return manage(res);
+  return this->set_range_tuple(isl::id(ctx(), id));
 }
 
-isl::multi_aff multi_aff::project_domain_on_params() const
+isl::multi_union_pw_aff multi_aff::set_union_pw_aff(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_multi_aff_project_domain_on_params(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).set_union_pw_aff(pos, el);
 }
 
-isl::multi_aff multi_aff::project_out_map(isl::space space, isl::dim type, unsigned int first, unsigned int n)
+class size multi_aff::size() const
 {
-  auto res = isl_multi_aff_project_out_map(space.release(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_multi_aff_size(get());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::pullback(isl::multi_aff ma2) const
+isl::space multi_aff::space() const
 {
-  auto res = isl_multi_aff_pullback_multi_aff(copy(), ma2.release());
+  auto res = isl_multi_aff_get_space(get());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::range_factor_domain() const
+isl::space multi_aff::get_space() const
 {
-  auto res = isl_multi_aff_range_factor_domain(copy());
-  return manage(res);
+  return space();
 }
 
-isl::multi_aff multi_aff::range_factor_range() const
+isl::multi_aff multi_aff::sub(isl::multi_aff multi2) const
 {
-  auto res = isl_multi_aff_range_factor_range(copy());
+  auto res = isl_multi_aff_sub(copy(), multi2.release());
   return manage(res);
 }
 
-boolean multi_aff::range_is_wrapping() const
+isl::multi_pw_aff multi_aff::sub(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_range_is_wrapping(get());
-  return manage(res);
+  return isl::pw_multi_aff(*this).sub(multi2);
 }
 
-isl::multi_aff multi_aff::range_map(isl::space space)
+isl::multi_union_pw_aff multi_aff::sub(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_aff_range_map(space.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).sub(multi2);
 }
 
-isl::multi_aff multi_aff::range_product(isl::multi_aff multi2) const
+isl::pw_multi_aff multi_aff::sub(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_multi_aff_range_product(copy(), multi2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).sub(pma2);
 }
 
-isl::multi_aff multi_aff::range_splice(unsigned int pos, isl::multi_aff multi2) const
+isl::union_pw_multi_aff multi_aff::sub(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_multi_aff_range_splice(copy(), pos, multi2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).sub(upma2);
 }
 
-isl::multi_aff multi_aff::reset_tuple_id(isl::dim type) const
+isl::multi_aff multi_aff::sub(const isl::aff &multi2) const
 {
-  auto res = isl_multi_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return this->sub(isl::multi_aff(multi2));
 }
 
-isl::multi_aff multi_aff::reset_user() const
+isl::pw_multi_aff multi_aff::subtract_domain(const isl::set &set) const
 {
-  auto res = isl_multi_aff_reset_user(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).subtract_domain(set);
 }
 
-isl::multi_aff multi_aff::scale(isl::multi_val mv) const
+isl::union_pw_multi_aff multi_aff::subtract_domain(const isl::space &space) const
 {
-  auto res = isl_multi_aff_scale_multi_val(copy(), mv.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).subtract_domain(space);
 }
 
-isl::multi_aff multi_aff::scale(isl::val v) const
+isl::union_pw_multi_aff multi_aff::subtract_domain(const isl::union_set &uset) const
 {
-  auto res = isl_multi_aff_scale_val(copy(), v.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).subtract_domain(uset);
 }
 
-isl::multi_aff multi_aff::scale_down(isl::multi_val mv) const
+isl::pw_multi_aff_list multi_aff::to_list() const
 {
-  auto res = isl_multi_aff_scale_down_multi_val(copy(), mv.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).to_list();
 }
 
-isl::multi_aff multi_aff::scale_down(isl::val v) const
+isl::multi_pw_aff multi_aff::to_multi_pw_aff() const
 {
-  auto res = isl_multi_aff_scale_down_val(copy(), v.release());
+  auto res = isl_multi_aff_to_multi_pw_aff(copy());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::set_aff(int pos, isl::aff el) const
+isl::multi_union_pw_aff multi_aff::to_multi_union_pw_aff() const
 {
-  auto res = isl_multi_aff_set_aff(copy(), pos, el.release());
+  auto res = isl_multi_aff_to_multi_union_pw_aff(copy());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::set_at(int pos, isl::aff el) const
+isl::pw_multi_aff multi_aff::to_pw_multi_aff() const
 {
-  auto res = isl_multi_aff_set_at(copy(), pos, el.release());
+  auto res = isl_multi_aff_to_pw_multi_aff(copy());
   return manage(res);
 }
 
-isl::multi_aff multi_aff::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::union_pw_multi_aff multi_aff::to_union_pw_multi_aff() const
 {
-  auto res = isl_multi_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).to_union_pw_multi_aff();
 }
 
-isl::multi_aff multi_aff::set_tuple_id(isl::dim type, isl::id id) const
+isl::id multi_aff::tuple_id(isl::dim type) const
 {
-  auto res = isl_multi_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).tuple_id(type);
 }
 
-isl::multi_aff multi_aff::set_tuple_name(isl::dim type, const std::string &s) const
+isl::multi_aff multi_aff::unbind_params_insert_domain(isl::multi_id domain) const
 {
-  auto res = isl_multi_aff_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
+  auto res = isl_multi_aff_unbind_params_insert_domain(copy(), domain.release());
   return manage(res);
 }
 
-isl_size multi_aff::size() const
+isl::multi_pw_aff multi_aff::union_add(const isl::multi_pw_aff &mpa2) const
 {
-  auto res = isl_multi_aff_size(get());
-  return res;
+  return isl::pw_multi_aff(*this).union_add(mpa2);
 }
 
-isl::multi_aff multi_aff::splice(unsigned int in_pos, unsigned int out_pos, isl::multi_aff multi2) const
+isl::multi_union_pw_aff multi_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
 {
-  auto res = isl_multi_aff_splice(copy(), in_pos, out_pos, multi2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).union_add(mupa2);
 }
 
-isl::multi_aff multi_aff::sub(isl::multi_aff multi2) const
+isl::pw_multi_aff multi_aff::union_add(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_multi_aff_sub(copy(), multi2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).union_add(pma2);
 }
 
-isl::multi_aff multi_aff::unbind_params_insert_domain(isl::multi_id domain) const
+isl::union_pw_multi_aff multi_aff::union_add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_multi_aff_unbind_params_insert_domain(copy(), domain.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).union_add(upma2);
 }
 
 isl::multi_aff multi_aff::zero(isl::space space)
 {
   auto res = isl_multi_aff_zero(space.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const multi_aff &obj)
+{
+  char *str = isl_multi_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::multi_id
 multi_id manage(__isl_take isl_multi_id *ptr) {
   return multi_id(ptr);
 }
 multi_id manage_copy(__isl_keep isl_multi_id *ptr) {
   ptr = isl_multi_id_copy(ptr);
   return multi_id(ptr);
 }
 
 multi_id::multi_id()
     : ptr(nullptr) {}
 
 multi_id::multi_id(const multi_id &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 multi_id::multi_id(__isl_take isl_multi_id *ptr)
     : ptr(ptr) {}
 
 multi_id::multi_id(isl::space space, isl::id_list list)
 {
   auto res = isl_multi_id_from_id_list(space.release(), list.release());
   ptr = res;
 }
+
 multi_id::multi_id(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_multi_id_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 multi_id &multi_id::operator=(multi_id obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_multi_id *multi_id::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_id::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx multi_id::ctx() const {
   return isl::ctx(isl_multi_id_get_ctx(ptr));
 }
 
-void multi_id::dump() const {
-  isl_multi_id_dump(get());
-}
-
-
-isl::multi_id multi_id::align_params(isl::space model) const
+isl::id multi_id::at(int pos) const
 {
-  auto res = isl_multi_id_align_params(copy(), model.release());
+  auto res = isl_multi_id_get_at(get(), pos);
   return manage(res);
 }
 
-isl::multi_id multi_id::factor_range() const
+isl::id multi_id::get_at(int pos) const
 {
-  auto res = isl_multi_id_factor_range(copy());
-  return manage(res);
+  return at(pos);
 }
 
 isl::multi_id multi_id::flat_range_product(isl::multi_id multi2) const
 {
   auto res = isl_multi_id_flat_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-isl::multi_id multi_id::flatten_range() const
-{
-  auto res = isl_multi_id_flatten_range(copy());
-  return manage(res);
-}
-
-isl::multi_id multi_id::from_range() const
-{
-  auto res = isl_multi_id_from_range(copy());
-  return manage(res);
-}
-
-isl::id multi_id::get_at(int pos) const
-{
-  auto res = isl_multi_id_get_at(get(), pos);
-  return manage(res);
-}
-
-isl::space multi_id::get_domain_space() const
-{
-  auto res = isl_multi_id_get_domain_space(get());
-  return manage(res);
-}
-
-isl::id multi_id::get_id(int pos) const
-{
-  auto res = isl_multi_id_get_id(get(), pos);
-  return manage(res);
-}
-
-isl::id_list multi_id::get_list() const
+isl::id_list multi_id::list() const
 {
   auto res = isl_multi_id_get_list(get());
   return manage(res);
 }
 
-isl::space multi_id::get_space() const
+isl::id_list multi_id::get_list() const
 {
-  auto res = isl_multi_id_get_space(get());
-  return manage(res);
+  return list();
 }
 
 boolean multi_id::plain_is_equal(const isl::multi_id &multi2) const
 {
   auto res = isl_multi_id_plain_is_equal(get(), multi2.get());
   return manage(res);
 }
 
-isl::multi_id multi_id::range_factor_domain() const
+isl::multi_id multi_id::range_product(isl::multi_id multi2) const
 {
-  auto res = isl_multi_id_range_factor_domain(copy());
+  auto res = isl_multi_id_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-isl::multi_id multi_id::range_factor_range() const
+isl::multi_id multi_id::set_at(int pos, isl::id el) const
 {
-  auto res = isl_multi_id_range_factor_range(copy());
+  auto res = isl_multi_id_set_at(copy(), pos, el.release());
   return manage(res);
 }
 
-boolean multi_id::range_is_wrapping() const
+isl::multi_id multi_id::set_at(int pos, const std::string &el) const
 {
-  auto res = isl_multi_id_range_is_wrapping(get());
-  return manage(res);
+  return this->set_at(pos, isl::id(ctx(), el));
 }
 
-isl::multi_id multi_id::range_product(isl::multi_id multi2) const
+isl::multi_id multi_id::set_id(int pos, isl::id el) const
 {
-  auto res = isl_multi_id_range_product(copy(), multi2.release());
+  auto res = isl_multi_id_set_id(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_id multi_id::range_splice(unsigned int pos, isl::multi_id multi2) const
+isl::multi_id multi_id::set_id(int pos, const std::string &el) const
 {
-  auto res = isl_multi_id_range_splice(copy(), pos, multi2.release());
-  return manage(res);
+  return this->set_id(pos, isl::id(ctx(), el));
 }
 
-isl::multi_id multi_id::reset_user() const
+class size multi_id::size() const
 {
-  auto res = isl_multi_id_reset_user(copy());
+  auto res = isl_multi_id_size(get());
   return manage(res);
 }
 
-isl::multi_id multi_id::set_at(int pos, isl::id el) const
+isl::space multi_id::space() const
 {
-  auto res = isl_multi_id_set_at(copy(), pos, el.release());
+  auto res = isl_multi_id_get_space(get());
   return manage(res);
 }
 
-isl::multi_id multi_id::set_id(int pos, isl::id el) const
+isl::space multi_id::get_space() const
 {
-  auto res = isl_multi_id_set_id(copy(), pos, el.release());
-  return manage(res);
+  return space();
 }
 
-isl_size multi_id::size() const
+inline std::ostream &operator<<(std::ostream &os, const multi_id &obj)
 {
-  auto res = isl_multi_id_size(get());
-  return res;
+  char *str = isl_multi_id_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::multi_pw_aff
 multi_pw_aff manage(__isl_take isl_multi_pw_aff *ptr) {
   return multi_pw_aff(ptr);
 }
 multi_pw_aff manage_copy(__isl_keep isl_multi_pw_aff *ptr) {
   ptr = isl_multi_pw_aff_copy(ptr);
   return multi_pw_aff(ptr);
 }
 
 multi_pw_aff::multi_pw_aff()
     : ptr(nullptr) {}
 
 multi_pw_aff::multi_pw_aff(const multi_pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 multi_pw_aff::multi_pw_aff(__isl_take isl_multi_pw_aff *ptr)
     : ptr(ptr) {}
 
 multi_pw_aff::multi_pw_aff(isl::aff aff)
 {
   auto res = isl_multi_pw_aff_from_aff(aff.release());
   ptr = res;
 }
+
 multi_pw_aff::multi_pw_aff(isl::multi_aff ma)
 {
   auto res = isl_multi_pw_aff_from_multi_aff(ma.release());
   ptr = res;
 }
+
 multi_pw_aff::multi_pw_aff(isl::pw_aff pa)
 {
   auto res = isl_multi_pw_aff_from_pw_aff(pa.release());
   ptr = res;
 }
+
 multi_pw_aff::multi_pw_aff(isl::space space, isl::pw_aff_list list)
 {
   auto res = isl_multi_pw_aff_from_pw_aff_list(space.release(), list.release());
   ptr = res;
 }
+
 multi_pw_aff::multi_pw_aff(isl::pw_multi_aff pma)
 {
   auto res = isl_multi_pw_aff_from_pw_multi_aff(pma.release());
   ptr = res;
 }
+
 multi_pw_aff::multi_pw_aff(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_multi_pw_aff_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 multi_pw_aff &multi_pw_aff::operator=(multi_pw_aff obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_multi_pw_aff *multi_pw_aff::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx multi_pw_aff::ctx() const {
   return isl::ctx(isl_multi_pw_aff_get_ctx(ptr));
 }
 
-void multi_pw_aff::dump() const {
-  isl_multi_pw_aff_dump(get());
-}
-
-
 isl::multi_pw_aff multi_pw_aff::add(isl::multi_pw_aff multi2) const
 {
   auto res = isl_multi_pw_aff_add(copy(), multi2.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::add_constant(isl::multi_val mv) const
+isl::multi_union_pw_aff multi_pw_aff::add(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_add_constant_multi_val(copy(), mv.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).add(multi2);
 }
 
-isl::multi_pw_aff multi_pw_aff::add_constant(isl::val v) const
+isl::multi_pw_aff multi_pw_aff::add(const isl::aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_add_constant_val(copy(), v.release());
-  return manage(res);
+  return this->add(isl::multi_pw_aff(multi2));
 }
 
-isl::multi_pw_aff multi_pw_aff::add_dims(isl::dim type, unsigned int n) const
+isl::multi_pw_aff multi_pw_aff::add(const isl::multi_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return this->add(isl::multi_pw_aff(multi2));
 }
 
-isl::multi_pw_aff multi_pw_aff::align_params(isl::space model) const
+isl::multi_pw_aff multi_pw_aff::add(const isl::pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_align_params(copy(), model.release());
-  return manage(res);
+  return this->add(isl::multi_pw_aff(multi2));
 }
 
-isl::set multi_pw_aff::bind(isl::multi_id tuple) const
+isl::multi_pw_aff multi_pw_aff::add(const isl::pw_multi_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_bind(copy(), tuple.release());
-  return manage(res);
+  return this->add(isl::multi_pw_aff(multi2));
 }
 
-isl::multi_pw_aff multi_pw_aff::bind_domain(isl::multi_id tuple) const
+isl::multi_pw_aff multi_pw_aff::add_constant(isl::multi_val mv) const
 {
-  auto res = isl_multi_pw_aff_bind_domain(copy(), tuple.release());
+  auto res = isl_multi_pw_aff_add_constant_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+isl::multi_pw_aff multi_pw_aff::add_constant(isl::val v) const
 {
-  auto res = isl_multi_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  auto res = isl_multi_pw_aff_add_constant_val(copy(), v.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::coalesce() const
+isl::multi_pw_aff multi_pw_aff::add_constant(long v) const
 {
-  auto res = isl_multi_pw_aff_coalesce(copy());
-  return manage(res);
+  return this->add_constant(isl::val(ctx(), v));
 }
 
-isl_size multi_pw_aff::dim(isl::dim type) const
+isl::map multi_pw_aff::as_map() const
 {
-  auto res = isl_multi_pw_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  auto res = isl_multi_pw_aff_as_map(copy());
+  return manage(res);
 }
 
-isl::set multi_pw_aff::domain() const
+isl::multi_aff multi_pw_aff::as_multi_aff() const
 {
-  auto res = isl_multi_pw_aff_domain(copy());
+  auto res = isl_multi_pw_aff_as_multi_aff(copy());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::set multi_pw_aff::as_set() const
 {
-  auto res = isl_multi_pw_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_multi_pw_aff_as_set(copy());
   return manage(res);
 }
 
-isl::map multi_pw_aff::eq_map(isl::multi_pw_aff mpa2) const
+isl::pw_aff multi_pw_aff::at(int pos) const
 {
-  auto res = isl_multi_pw_aff_eq_map(copy(), mpa2.release());
+  auto res = isl_multi_pw_aff_get_at(get(), pos);
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::factor_range() const
+isl::pw_aff multi_pw_aff::get_at(int pos) const
 {
-  auto res = isl_multi_pw_aff_factor_range(copy());
-  return manage(res);
+  return at(pos);
 }
 
-int multi_pw_aff::find_dim_by_id(isl::dim type, const isl::id &id) const
+isl::set multi_pw_aff::bind(isl::multi_id tuple) const
 {
-  auto res = isl_multi_pw_aff_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
-  return res;
+  auto res = isl_multi_pw_aff_bind(copy(), tuple.release());
+  return manage(res);
 }
 
-int multi_pw_aff::find_dim_by_name(isl::dim type, const std::string &name) const
+isl::multi_pw_aff multi_pw_aff::bind_domain(isl::multi_id tuple) const
 {
-  auto res = isl_multi_pw_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  auto res = isl_multi_pw_aff_bind_domain(copy(), tuple.release());
+  return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::flat_range_product(isl::multi_pw_aff multi2) const
+isl::multi_pw_aff multi_pw_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
 {
-  auto res = isl_multi_pw_aff_flat_range_product(copy(), multi2.release());
+  auto res = isl_multi_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::flatten_range() const
+isl::multi_pw_aff multi_pw_aff::coalesce() const
 {
-  auto res = isl_multi_pw_aff_flatten_range(copy());
+  auto res = isl_multi_pw_aff_coalesce(copy());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::from_range() const
+class size multi_pw_aff::dim(isl::dim type) const
 {
-  auto res = isl_multi_pw_aff_from_range(copy());
+  auto res = isl_multi_pw_aff_dim(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::pw_aff multi_pw_aff::get_at(int pos) const
+isl::set multi_pw_aff::domain() const
 {
-  auto res = isl_multi_pw_aff_get_at(get(), pos);
+  auto res = isl_multi_pw_aff_domain(copy());
   return manage(res);
 }
 
-isl::id multi_pw_aff::get_dim_id(isl::dim type, unsigned int pos) const
+isl::multi_pw_aff multi_pw_aff::flat_range_product(isl::multi_pw_aff multi2) const
 {
-  auto res = isl_multi_pw_aff_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_multi_pw_aff_flat_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-isl::space multi_pw_aff::get_domain_space() const
+isl::multi_union_pw_aff multi_pw_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_get_domain_space(get());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).flat_range_product(multi2);
 }
 
-uint32_t multi_pw_aff::get_hash() const
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_get_hash(get());
-  return res;
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
 }
 
-isl::pw_aff_list multi_pw_aff::get_list() const
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::multi_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_get_list(get());
-  return manage(res);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
 }
 
-isl::pw_aff multi_pw_aff::get_pw_aff(int pos) const
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_get_pw_aff(get(), pos);
-  return manage(res);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
 }
 
-isl::space multi_pw_aff::get_space() const
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::pw_multi_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_get_space(get());
-  return manage(res);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
 }
 
-isl::id multi_pw_aff::get_tuple_id(isl::dim type) const
+isl::multi_pw_aff multi_pw_aff::gist(isl::set set) const
 {
-  auto res = isl_multi_pw_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_multi_pw_aff_gist(copy(), set.release());
   return manage(res);
 }
 
-std::string multi_pw_aff::get_tuple_name(isl::dim type) const
+isl::multi_union_pw_aff multi_pw_aff::gist(const isl::union_set &context) const
 {
-  auto res = isl_multi_pw_aff_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
+  return isl::multi_union_pw_aff(*this).gist(context);
 }
 
-isl::multi_pw_aff multi_pw_aff::gist(isl::set set) const
+isl::multi_pw_aff multi_pw_aff::gist(const isl::basic_set &set) const
 {
-  auto res = isl_multi_pw_aff_gist(copy(), set.release());
-  return manage(res);
+  return this->gist(isl::set(set));
 }
 
-isl::multi_pw_aff multi_pw_aff::gist_params(isl::set set) const
+isl::multi_pw_aff multi_pw_aff::gist(const isl::point &set) const
 {
-  auto res = isl_multi_pw_aff_gist_params(copy(), set.release());
-  return manage(res);
+  return this->gist(isl::set(set));
 }
 
-boolean multi_pw_aff::has_tuple_id(isl::dim type) const
+boolean multi_pw_aff::has_range_tuple_id() const
 {
-  auto res = isl_multi_pw_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_multi_pw_aff_has_range_tuple_id(get());
   return manage(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::identity() const
 {
   auto res = isl_multi_pw_aff_identity_multi_pw_aff(copy());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::identity_on_domain(isl::space space)
 {
   auto res = isl_multi_pw_aff_identity_on_domain_space(space.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_multi_pw_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
 isl::multi_pw_aff multi_pw_aff::insert_domain(isl::space domain) const
 {
   auto res = isl_multi_pw_aff_insert_domain(copy(), domain.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::intersect_domain(isl::set domain) const
 {
   auto res = isl_multi_pw_aff_intersect_domain(copy(), domain.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::intersect_params(isl::set set) const
+isl::multi_union_pw_aff multi_pw_aff::intersect_domain(const isl::union_set &uset) const
 {
-  auto res = isl_multi_pw_aff_intersect_params(copy(), set.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).intersect_domain(uset);
 }
 
-boolean multi_pw_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::multi_pw_aff multi_pw_aff::intersect_domain(const isl::basic_set &domain) const
 {
-  auto res = isl_multi_pw_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->intersect_domain(isl::set(domain));
 }
 
-boolean multi_pw_aff::involves_nan() const
+isl::multi_pw_aff multi_pw_aff::intersect_domain(const isl::point &domain) const
 {
-  auto res = isl_multi_pw_aff_involves_nan(get());
-  return manage(res);
+  return this->intersect_domain(isl::set(domain));
 }
 
-boolean multi_pw_aff::involves_param(const isl::id &id) const
+isl::multi_pw_aff multi_pw_aff::intersect_params(isl::set set) const
 {
-  auto res = isl_multi_pw_aff_involves_param_id(get(), id.get());
+  auto res = isl_multi_pw_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-boolean multi_pw_aff::involves_param(const isl::id_list &list) const
+boolean multi_pw_aff::involves_nan() const
 {
-  auto res = isl_multi_pw_aff_involves_param_id_list(get(), list.get());
+  auto res = isl_multi_pw_aff_involves_nan(get());
   return manage(res);
 }
 
-boolean multi_pw_aff::is_cst() const
+boolean multi_pw_aff::involves_param(const isl::id &id) const
 {
-  auto res = isl_multi_pw_aff_is_cst(get());
+  auto res = isl_multi_pw_aff_involves_param_id(get(), id.get());
   return manage(res);
 }
 
-boolean multi_pw_aff::is_equal(const isl::multi_pw_aff &mpa2) const
+boolean multi_pw_aff::involves_param(const std::string &id) const
 {
-  auto res = isl_multi_pw_aff_is_equal(get(), mpa2.get());
-  return manage(res);
+  return this->involves_param(isl::id(ctx(), id));
 }
 
-isl::map multi_pw_aff::lex_ge_map(isl::multi_pw_aff mpa2) const
+boolean multi_pw_aff::involves_param(const isl::id_list &list) const
 {
-  auto res = isl_multi_pw_aff_lex_ge_map(copy(), mpa2.release());
+  auto res = isl_multi_pw_aff_involves_param_id_list(get(), list.get());
   return manage(res);
 }
 
-isl::map multi_pw_aff::lex_gt_map(isl::multi_pw_aff mpa2) const
+boolean multi_pw_aff::isa_multi_aff() const
 {
-  auto res = isl_multi_pw_aff_lex_gt_map(copy(), mpa2.release());
+  auto res = isl_multi_pw_aff_isa_multi_aff(get());
   return manage(res);
 }
 
-isl::map multi_pw_aff::lex_le_map(isl::multi_pw_aff mpa2) const
+isl::pw_aff_list multi_pw_aff::list() const
 {
-  auto res = isl_multi_pw_aff_lex_le_map(copy(), mpa2.release());
+  auto res = isl_multi_pw_aff_get_list(get());
   return manage(res);
 }
 
-isl::map multi_pw_aff::lex_lt_map(isl::multi_pw_aff mpa2) const
+isl::pw_aff_list multi_pw_aff::get_list() const
 {
-  auto res = isl_multi_pw_aff_lex_lt_map(copy(), mpa2.release());
-  return manage(res);
+  return list();
 }
 
 isl::multi_pw_aff multi_pw_aff::max(isl::multi_pw_aff multi2) const
 {
   auto res = isl_multi_pw_aff_max(copy(), multi2.release());
   return manage(res);
 }
 

 }
 
 isl::multi_val multi_pw_aff::min_multi_val() const
 {
   auto res = isl_multi_pw_aff_min_multi_val(copy());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::mod_multi_val(isl::multi_val mv) const
+isl::multi_pw_aff multi_pw_aff::neg() const
 {
-  auto res = isl_multi_pw_aff_mod_multi_val(copy(), mv.release());
+  auto res = isl_multi_pw_aff_neg(copy());
   return manage(res);
 }
 
-isl::multi_pw_aff 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
+boolean multi_pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_move_dims(copy(), static_cast<enum isl_dim_type>(dst_type), dst_pos, static_cast<enum isl_dim_type>(src_type), src_pos, n);
+  auto res = isl_multi_pw_aff_plain_is_equal(get(), multi2.get());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::neg() const
+boolean multi_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_neg(copy());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).plain_is_equal(multi2);
 }
 
-boolean multi_pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+boolean multi_pw_aff::plain_is_equal(const isl::aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_plain_is_equal(get(), multi2.get());
-  return manage(res);
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
 }
 
-isl::multi_pw_aff multi_pw_aff::product(isl::multi_pw_aff multi2) const
+boolean multi_pw_aff::plain_is_equal(const isl::multi_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_product(copy(), multi2.release());
-  return manage(res);
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::pw_aff &multi2) const
+{
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
 }
 
-isl::multi_pw_aff multi_pw_aff::project_domain_on_params() const
+boolean multi_pw_aff::plain_is_equal(const isl::pw_multi_aff &multi2) const
+{
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::product(isl::multi_pw_aff multi2) const
 {
-  auto res = isl_multi_pw_aff_project_domain_on_params(copy());
+  auto res = isl_multi_pw_aff_product(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::pullback(isl::multi_aff ma) const
 {
   auto res = isl_multi_pw_aff_pullback_multi_aff(copy(), ma.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::pullback(isl::multi_pw_aff mpa2) const
 {
   auto res = isl_multi_pw_aff_pullback_multi_pw_aff(copy(), mpa2.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::pullback(isl::pw_multi_aff pma) const
 {
   auto res = isl_multi_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::range_factor_domain() const
+isl::multi_union_pw_aff multi_pw_aff::pullback(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_multi_pw_aff_range_factor_domain(copy());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).pullback(upma);
 }
 
-isl::multi_pw_aff multi_pw_aff::range_factor_range() const
+isl::multi_pw_aff multi_pw_aff::range_product(isl::multi_pw_aff multi2) const
 {
-  auto res = isl_multi_pw_aff_range_factor_range(copy());
+  auto res = isl_multi_pw_aff_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-boolean multi_pw_aff::range_is_wrapping() const
+isl::multi_union_pw_aff multi_pw_aff::range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_range_is_wrapping(get());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).range_product(multi2);
 }
 
-isl::multi_pw_aff multi_pw_aff::range_product(isl::multi_pw_aff multi2) const
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_range_product(copy(), multi2.release());
-  return manage(res);
+  return this->range_product(isl::multi_pw_aff(multi2));
 }
 
-isl::multi_pw_aff multi_pw_aff::range_splice(unsigned int pos, isl::multi_pw_aff multi2) const
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::multi_aff &multi2) const
 {
-  auto res = isl_multi_pw_aff_range_splice(copy(), pos, multi2.release());
+  return this->range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::pw_aff &multi2) const
+{
+  return this->range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::pw_multi_aff &multi2) const
+{
+  return this->range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::id multi_pw_aff::range_tuple_id() const
+{
+  auto res = isl_multi_pw_aff_get_range_tuple_id(get());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::reset_tuple_id(isl::dim type) const
+isl::id multi_pw_aff::get_range_tuple_id() const
 {
-  auto res = isl_multi_pw_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
+  return range_tuple_id();
+}
+
+isl::multi_pw_aff multi_pw_aff::reset_range_tuple_id() const
+{
+  auto res = isl_multi_pw_aff_reset_range_tuple_id(copy());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::reset_user() const
+isl::multi_pw_aff multi_pw_aff::reset_tuple_id(isl::dim type) const
 {
-  auto res = isl_multi_pw_aff_reset_user(copy());
+  auto res = isl_multi_pw_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::scale(isl::multi_val mv) const
 {
   auto res = isl_multi_pw_aff_scale_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::scale(isl::val v) const
 {
   auto res = isl_multi_pw_aff_scale_val(copy(), v.release());
   return manage(res);
 }
 
+isl::multi_pw_aff multi_pw_aff::scale(long v) const
+{
+  return this->scale(isl::val(ctx(), v));
+}
+
 isl::multi_pw_aff multi_pw_aff::scale_down(isl::multi_val mv) const
 {
   auto res = isl_multi_pw_aff_scale_down_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::scale_down(isl::val v) const
 {
   auto res = isl_multi_pw_aff_scale_down_val(copy(), v.release());
   return manage(res);
 }
 
+isl::multi_pw_aff multi_pw_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::val(ctx(), v));
+}
+
 isl::multi_pw_aff multi_pw_aff::set_at(int pos, isl::pw_aff el) const
 {
   auto res = isl_multi_pw_aff_set_at(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::multi_union_pw_aff multi_pw_aff::set_at(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_multi_pw_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).set_at(pos, el);
 }
 
 isl::multi_pw_aff multi_pw_aff::set_pw_aff(int pos, isl::pw_aff el) const
 {
   auto res = isl_multi_pw_aff_set_pw_aff(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::set_tuple_id(isl::dim type, isl::id id) const
+isl::multi_pw_aff multi_pw_aff::set_range_tuple(isl::id id) const
 {
-  auto res = isl_multi_pw_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
+  auto res = isl_multi_pw_aff_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::set_tuple_name(isl::dim type, const std::string &s) const
+isl::multi_pw_aff multi_pw_aff::set_range_tuple(const std::string &id) const
 {
-  auto res = isl_multi_pw_aff_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
-  return manage(res);
+  return this->set_range_tuple(isl::id(ctx(), id));
 }
 
-isl_size multi_pw_aff::size() const
+isl::multi_union_pw_aff multi_pw_aff::set_union_pw_aff(int pos, const isl::union_pw_aff &el) const
+{
+  return isl::multi_union_pw_aff(*this).set_union_pw_aff(pos, el);
+}
+
+class size multi_pw_aff::size() const
 {
   auto res = isl_multi_pw_aff_size(get());
-  return res;
+  return manage(res);
 }
 
-isl::multi_pw_aff multi_pw_aff::splice(unsigned int in_pos, unsigned int out_pos, isl::multi_pw_aff multi2) const
+isl::space multi_pw_aff::space() const
 {
-  auto res = isl_multi_pw_aff_splice(copy(), in_pos, out_pos, multi2.release());
+  auto res = isl_multi_pw_aff_get_space(get());
   return manage(res);
 }
 
+isl::space multi_pw_aff::get_space() const
+{
+  return space();
+}
+
 isl::multi_pw_aff multi_pw_aff::sub(isl::multi_pw_aff multi2) const
 {
   auto res = isl_multi_pw_aff_sub(copy(), multi2.release());
   return manage(res);
 }
 
+isl::multi_union_pw_aff multi_pw_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::multi_union_pw_aff(*this).sub(multi2);
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::aff &multi2) const
+{
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::multi_aff &multi2) const
+{
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::pw_aff &multi2) const
+{
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::pw_multi_aff &multi2) const
+{
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
 isl::multi_pw_aff multi_pw_aff::unbind_params_insert_domain(isl::multi_id domain) const
 {
   auto res = isl_multi_pw_aff_unbind_params_insert_domain(copy(), domain.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::union_add(isl::multi_pw_aff mpa2) const
 {
   auto res = isl_multi_pw_aff_union_add(copy(), mpa2.release());
   return manage(res);
 }
 
+isl::multi_union_pw_aff multi_pw_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  return isl::multi_union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::aff &mpa2) const
+{
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::multi_aff &mpa2) const
+{
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::pw_aff &mpa2) const
+{
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::pw_multi_aff &mpa2) const
+{
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
 isl::multi_pw_aff multi_pw_aff::zero(isl::space space)
 {
   auto res = isl_multi_pw_aff_zero(space.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const multi_pw_aff &obj)
+{
+  char *str = isl_multi_pw_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::multi_union_pw_aff
 multi_union_pw_aff manage(__isl_take isl_multi_union_pw_aff *ptr) {
   return multi_union_pw_aff(ptr);
 }
 multi_union_pw_aff manage_copy(__isl_keep isl_multi_union_pw_aff *ptr) {
   ptr = isl_multi_union_pw_aff_copy(ptr);
   return multi_union_pw_aff(ptr);
 }
 
 multi_union_pw_aff::multi_union_pw_aff()
     : ptr(nullptr) {}
 
 multi_union_pw_aff::multi_union_pw_aff(const multi_union_pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 multi_union_pw_aff::multi_union_pw_aff(__isl_take isl_multi_union_pw_aff *ptr)
     : ptr(ptr) {}
 
 multi_union_pw_aff::multi_union_pw_aff(isl::multi_pw_aff mpa)
 {
   auto res = isl_multi_union_pw_aff_from_multi_pw_aff(mpa.release());
   ptr = res;
 }
+
 multi_union_pw_aff::multi_union_pw_aff(isl::union_pw_aff upa)
 {
   auto res = isl_multi_union_pw_aff_from_union_pw_aff(upa.release());
   ptr = res;
 }
+
 multi_union_pw_aff::multi_union_pw_aff(isl::space space, isl::union_pw_aff_list list)
 {
   auto res = isl_multi_union_pw_aff_from_union_pw_aff_list(space.release(), list.release());
   ptr = res;
 }
+
 multi_union_pw_aff::multi_union_pw_aff(isl::union_pw_multi_aff upma)
 {
   auto res = isl_multi_union_pw_aff_from_union_pw_multi_aff(upma.release());
   ptr = res;
 }
+
 multi_union_pw_aff::multi_union_pw_aff(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_multi_union_pw_aff_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 multi_union_pw_aff &multi_union_pw_aff::operator=(multi_union_pw_aff obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_multi_union_pw_aff *multi_union_pw_aff::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_union_pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx multi_union_pw_aff::ctx() const {
   return isl::ctx(isl_multi_union_pw_aff_get_ctx(ptr));
 }
 
-void multi_union_pw_aff::dump() const {
-  isl_multi_union_pw_aff_dump(get());
-}
-
-
 isl::multi_union_pw_aff multi_union_pw_aff::add(isl::multi_union_pw_aff multi2) const
 {
   auto res = isl_multi_union_pw_aff_add(copy(), multi2.release());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::align_params(isl::space model) const
+isl::union_pw_aff multi_union_pw_aff::at(int pos) const
 {
-  auto res = isl_multi_union_pw_aff_align_params(copy(), model.release());
-  return manage(res);
-}
-
-isl::union_pw_aff multi_union_pw_aff::apply_aff(isl::aff aff) const
-{
-  auto res = isl_multi_union_pw_aff_apply_aff(copy(), aff.release());
-  return manage(res);
-}
-
-isl::union_pw_aff multi_union_pw_aff::apply_pw_aff(isl::pw_aff pa) const
-{
-  auto res = isl_multi_union_pw_aff_apply_pw_aff(copy(), pa.release());
+  auto res = isl_multi_union_pw_aff_get_at(get(), pos);
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::apply_pw_multi_aff(isl::pw_multi_aff pma) const
+isl::union_pw_aff multi_union_pw_aff::get_at(int pos) const
 {
-  auto res = isl_multi_union_pw_aff_apply_pw_multi_aff(copy(), pma.release());
-  return manage(res);
+  return at(pos);
 }
 
 isl::union_set multi_union_pw_aff::bind(isl::multi_id tuple) const
 {
   auto res = isl_multi_union_pw_aff_bind(copy(), tuple.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::coalesce() const
 {
   auto res = isl_multi_union_pw_aff_coalesce(copy());
   return manage(res);
 }
 
-isl_size multi_union_pw_aff::dim(isl::dim type) const
+class size multi_union_pw_aff::dim(isl::dim type) const
 {
   auto res = isl_multi_union_pw_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return manage(res);
 }
 
 isl::union_set multi_union_pw_aff::domain() const
 {
   auto res = isl_multi_union_pw_aff_domain(copy());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_multi_union_pw_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
-isl::multi_pw_aff multi_union_pw_aff::extract_multi_pw_aff(isl::space space) const
-{
-  auto res = isl_multi_union_pw_aff_extract_multi_pw_aff(get(), space.release());
-  return manage(res);
-}
-
-isl::multi_union_pw_aff multi_union_pw_aff::factor_range() const
-{
-  auto res = isl_multi_union_pw_aff_factor_range(copy());
-  return manage(res);
-}
-
-int multi_union_pw_aff::find_dim_by_id(isl::dim type, const isl::id &id) const
-{
-  auto res = isl_multi_union_pw_aff_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
-  return res;
-}
-
-int multi_union_pw_aff::find_dim_by_name(isl::dim type, const std::string &name) const
-{
-  auto res = isl_multi_union_pw_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
-}
-
 isl::multi_union_pw_aff multi_union_pw_aff::flat_range_product(isl::multi_union_pw_aff multi2) const
 {
   auto res = isl_multi_union_pw_aff_flat_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::flatten_range() const
-{
-  auto res = isl_multi_union_pw_aff_flatten_range(copy());
-  return manage(res);
-}
-
-isl::multi_union_pw_aff multi_union_pw_aff::floor() const
-{
-  auto res = isl_multi_union_pw_aff_floor(copy());
-  return manage(res);
-}
-
-isl::multi_union_pw_aff multi_union_pw_aff::from_multi_aff(isl::multi_aff ma)
-{
-  auto res = isl_multi_union_pw_aff_from_multi_aff(ma.release());
-  return manage(res);
-}
-
-isl::multi_union_pw_aff multi_union_pw_aff::from_range() const
-{
-  auto res = isl_multi_union_pw_aff_from_range(copy());
-  return manage(res);
-}
-
 isl::multi_union_pw_aff multi_union_pw_aff::from_union_map(isl::union_map umap)
 {
   auto res = isl_multi_union_pw_aff_from_union_map(umap.release());
   return manage(res);
 }
 
-isl::union_pw_aff multi_union_pw_aff::get_at(int pos) const
-{
-  auto res = isl_multi_union_pw_aff_get_at(get(), pos);
-  return manage(res);
-}
-
-isl::id multi_union_pw_aff::get_dim_id(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_multi_union_pw_aff_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
-}
-
-isl::space multi_union_pw_aff::get_domain_space() const
-{
-  auto res = isl_multi_union_pw_aff_get_domain_space(get());
-  return manage(res);
-}
-
-isl::union_pw_aff_list multi_union_pw_aff::get_list() const
-{
-  auto res = isl_multi_union_pw_aff_get_list(get());
-  return manage(res);
-}
-
-isl::space multi_union_pw_aff::get_space() const
-{
-  auto res = isl_multi_union_pw_aff_get_space(get());
-  return manage(res);
-}
-
-isl::id multi_union_pw_aff::get_tuple_id(isl::dim type) const
-{
-  auto res = isl_multi_union_pw_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
-}
-
-std::string multi_union_pw_aff::get_tuple_name(isl::dim type) const
-{
-  auto res = isl_multi_union_pw_aff_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
-}
-
-isl::union_pw_aff multi_union_pw_aff::get_union_pw_aff(int pos) const
-{
-  auto res = isl_multi_union_pw_aff_get_union_pw_aff(get(), pos);
-  return manage(res);
-}
-
 isl::multi_union_pw_aff multi_union_pw_aff::gist(isl::union_set context) const
 {
   auto res = isl_multi_union_pw_aff_gist(copy(), context.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);
-}
-
-boolean multi_union_pw_aff::has_tuple_id(isl::dim type) const
+boolean multi_union_pw_aff::has_range_tuple_id() const
 {
-  auto res = isl_multi_union_pw_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_multi_union_pw_aff_has_range_tuple_id(get());
   return manage(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);
-}
-
 boolean multi_union_pw_aff::involves_nan() const
 {
   auto res = isl_multi_union_pw_aff_involves_nan(get());
   return manage(res);
 }
 
-isl::multi_val multi_union_pw_aff::max_multi_val() const
+isl::union_pw_aff_list multi_union_pw_aff::list() const
 {
-  auto res = isl_multi_union_pw_aff_max_multi_val(copy());
-  return manage(res);
-}
-
-isl::multi_val multi_union_pw_aff::min_multi_val() const
-{
-  auto res = isl_multi_union_pw_aff_min_multi_val(copy());
-  return manage(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::multi_aff_on_domain(isl::union_set domain, isl::multi_aff ma)
-{
-  auto res = isl_multi_union_pw_aff_multi_aff_on_domain(domain.release(), ma.release());
+  auto res = isl_multi_union_pw_aff_get_list(get());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::multi_val_on_domain(isl::union_set domain, isl::multi_val mv)
+isl::union_pw_aff_list multi_union_pw_aff::get_list() const
 {
-  auto res = isl_multi_union_pw_aff_multi_val_on_domain(domain.release(), mv.release());
-  return manage(res);
+  return list();
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::neg() const
 {
   auto res = isl_multi_union_pw_aff_neg(copy());
   return manage(res);
 }
 
 boolean multi_union_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
 {
   auto res = isl_multi_union_pw_aff_plain_is_equal(get(), multi2.get());
   return manage(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::pw_multi_aff_on_domain(isl::union_set domain, isl::pw_multi_aff pma)
-{
-  auto res = isl_multi_union_pw_aff_pw_multi_aff_on_domain(domain.release(), pma.release());
-  return manage(res);
-}
-
-isl::multi_union_pw_aff multi_union_pw_aff::range_factor_domain() const
-{
-  auto res = isl_multi_union_pw_aff_range_factor_domain(copy());
-  return manage(res);
-}
-
-isl::multi_union_pw_aff multi_union_pw_aff::range_factor_range() const
+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_factor_range(copy());
+  auto res = isl_multi_union_pw_aff_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-boolean multi_union_pw_aff::range_is_wrapping() const
+isl::id multi_union_pw_aff::range_tuple_id() const
 {
-  auto res = isl_multi_union_pw_aff_range_is_wrapping(get());
+  auto res = isl_multi_union_pw_aff_get_range_tuple_id(get());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::range_product(isl::multi_union_pw_aff multi2) const
+isl::id multi_union_pw_aff::get_range_tuple_id() const
 {
-  auto res = isl_multi_union_pw_aff_range_product(copy(), multi2.release());
-  return manage(res);
+  return range_tuple_id();
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::range_splice(unsigned int pos, isl::multi_union_pw_aff multi2) const
+isl::multi_union_pw_aff multi_union_pw_aff::reset_range_tuple_id() const
 {
-  auto res = isl_multi_union_pw_aff_range_splice(copy(), pos, multi2.release());
+  auto res = isl_multi_union_pw_aff_reset_range_tuple_id(copy());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::reset_tuple_id(isl::dim type) const
 {
   auto res = isl_multi_union_pw_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::reset_user() const
-{
-  auto res = isl_multi_union_pw_aff_reset_user(copy());
-  return manage(res);
-}
-
 isl::multi_union_pw_aff multi_union_pw_aff::scale(isl::multi_val mv) const
 {
   auto res = isl_multi_union_pw_aff_scale_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::scale(isl::val v) const
 {
   auto res = isl_multi_union_pw_aff_scale_val(copy(), v.release());
   return manage(res);
 }
 
+isl::multi_union_pw_aff multi_union_pw_aff::scale(long v) const
+{
+  return this->scale(isl::val(ctx(), v));
+}
+
 isl::multi_union_pw_aff multi_union_pw_aff::scale_down(isl::multi_val mv) const
 {
   auto res = isl_multi_union_pw_aff_scale_down_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::scale_down(isl::val v) const
 {
   auto res = isl_multi_union_pw_aff_scale_down_val(copy(), v.release());
   return manage(res);
 }
 
+isl::multi_union_pw_aff multi_union_pw_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::val(ctx(), v));
+}
+
 isl::multi_union_pw_aff multi_union_pw_aff::set_at(int pos, isl::union_pw_aff el) const
 {
   auto res = isl_multi_union_pw_aff_set_at(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::multi_union_pw_aff multi_union_pw_aff::set_range_tuple(isl::id id) const
 {
-  auto res = isl_multi_union_pw_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
+  auto res = isl_multi_union_pw_aff_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::set_tuple_id(isl::dim type, isl::id id) const
+isl::multi_union_pw_aff multi_union_pw_aff::set_range_tuple(const std::string &id) const
 {
-  auto res = isl_multi_union_pw_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::set_union_pw_aff(int pos, isl::union_pw_aff el) const
+{
+  auto res = isl_multi_union_pw_aff_set_union_pw_aff(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::set_tuple_name(isl::dim type, const std::string &s) const
+class size multi_union_pw_aff::size() const
 {
-  auto res = isl_multi_union_pw_aff_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
+  auto res = isl_multi_union_pw_aff_size(get());
   return manage(res);
 }
 
-isl::multi_union_pw_aff multi_union_pw_aff::set_union_pw_aff(int pos, isl::union_pw_aff el) const
+isl::space multi_union_pw_aff::space() const
 {
-  auto res = isl_multi_union_pw_aff_set_union_pw_aff(copy(), pos, el.release());
+  auto res = isl_multi_union_pw_aff_get_space(get());
   return manage(res);
 }
 
-isl_size multi_union_pw_aff::size() const
+isl::space multi_union_pw_aff::get_space() const
 {
-  auto res = isl_multi_union_pw_aff_size(get());
-  return res;
+  return space();
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::sub(isl::multi_union_pw_aff multi2) const
 {
   auto res = isl_multi_union_pw_aff_sub(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::union_add(isl::multi_union_pw_aff mupa2) const
 {
   auto res = isl_multi_union_pw_aff_union_add(copy(), mupa2.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::zero(isl::space space)
 {
   auto res = isl_multi_union_pw_aff_zero(space.release());
   return manage(res);
 }
 
-isl::union_set multi_union_pw_aff::zero_union_set() const
+inline std::ostream &operator<<(std::ostream &os, const multi_union_pw_aff &obj)
 {
-  auto res = isl_multi_union_pw_aff_zero_union_set(copy());
-  return manage(res);
+  char *str = isl_multi_union_pw_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::multi_val
 multi_val manage(__isl_take isl_multi_val *ptr) {
   return multi_val(ptr);
 }
 multi_val manage_copy(__isl_keep isl_multi_val *ptr) {
   ptr = isl_multi_val_copy(ptr);
   return multi_val(ptr);
 }
 
 multi_val::multi_val()
     : ptr(nullptr) {}
 
 multi_val::multi_val(const multi_val &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 multi_val::multi_val(__isl_take isl_multi_val *ptr)
     : ptr(ptr) {}
 
 multi_val::multi_val(isl::space space, isl::val_list list)
 {
   auto res = isl_multi_val_from_val_list(space.release(), list.release());
   ptr = res;
 }
+
 multi_val::multi_val(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_multi_val_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 multi_val &multi_val::operator=(multi_val obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_multi_val *multi_val::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_val::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx multi_val::ctx() const {
   return isl::ctx(isl_multi_val_get_ctx(ptr));
 }
 
-void multi_val::dump() const {
-  isl_multi_val_dump(get());
-}
-
-
 isl::multi_val multi_val::add(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_add(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::add(isl::val v) const
 {
   auto res = isl_multi_val_add_val(copy(), v.release());
   return manage(res);
 }
 
-isl::multi_val multi_val::add_dims(isl::dim type, unsigned int n) const
+isl::multi_val multi_val::add(long v) const
 {
-  auto res = isl_multi_val_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return this->add(isl::val(ctx(), v));
 }
 
-isl::multi_val multi_val::align_params(isl::space model) const
+isl::val multi_val::at(int pos) const
 {
-  auto res = isl_multi_val_align_params(copy(), model.release());
+  auto res = isl_multi_val_get_at(get(), pos);
   return manage(res);
 }
 
-isl_size multi_val::dim(isl::dim type) const
-{
-  auto res = isl_multi_val_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
-}
-
-isl::multi_val multi_val::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::val multi_val::get_at(int pos) const
 {
-  auto res = isl_multi_val_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return at(pos);
 }
 
-isl::multi_val multi_val::factor_range() const
+class size multi_val::dim(isl::dim type) const
 {
-  auto res = isl_multi_val_factor_range(copy());
+  auto res = isl_multi_val_dim(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-int multi_val::find_dim_by_id(isl::dim type, const isl::id &id) const
-{
-  auto res = isl_multi_val_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
-  return res;
-}
-
-int multi_val::find_dim_by_name(isl::dim type, const std::string &name) const
-{
-  auto res = isl_multi_val_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
-}
-
 isl::multi_val multi_val::flat_range_product(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_flat_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-isl::multi_val multi_val::flatten_range() const
-{
-  auto res = isl_multi_val_flatten_range(copy());
-  return manage(res);
-}
-
-isl::multi_val multi_val::from_range() const
-{
-  auto res = isl_multi_val_from_range(copy());
-  return manage(res);
-}
-
-isl::val multi_val::get_at(int pos) const
+boolean multi_val::has_range_tuple_id() const
 {
-  auto res = isl_multi_val_get_at(get(), pos);
+  auto res = isl_multi_val_has_range_tuple_id(get());
   return manage(res);
 }
 
-isl::id multi_val::get_dim_id(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_multi_val_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
-}
-
-isl::space multi_val::get_domain_space() const
+boolean multi_val::involves_nan() const
 {
-  auto res = isl_multi_val_get_domain_space(get());
+  auto res = isl_multi_val_involves_nan(get());
   return manage(res);
 }
 
-isl::val_list multi_val::get_list() const
+isl::val_list multi_val::list() const
 {
   auto res = isl_multi_val_get_list(get());
   return manage(res);
 }
 
-isl::space multi_val::get_space() const
-{
-  auto res = isl_multi_val_get_space(get());
-  return manage(res);
-}
-
-isl::id multi_val::get_tuple_id(isl::dim type) const
-{
-  auto res = isl_multi_val_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
-}
-
-std::string multi_val::get_tuple_name(isl::dim type) const
-{
-  auto res = isl_multi_val_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
-}
-
-isl::val multi_val::get_val(int pos) const
-{
-  auto res = isl_multi_val_get_val(get(), pos);
-  return manage(res);
-}
-
-boolean multi_val::has_tuple_id(isl::dim type) const
-{
-  auto res = isl_multi_val_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(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);
-}
-
-boolean multi_val::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_multi_val_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
-boolean multi_val::involves_nan() const
-{
-  auto res = isl_multi_val_involves_nan(get());
-  return manage(res);
-}
-
-boolean multi_val::is_zero() const
+isl::val_list multi_val::get_list() const
 {
-  auto res = isl_multi_val_is_zero(get());
-  return manage(res);
+  return list();
 }
 
 isl::multi_val multi_val::max(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_max(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::min(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_min(copy(), multi2.release());
   return manage(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);
 }
 
 boolean multi_val::plain_is_equal(const isl::multi_val &multi2) const
 {
   auto res = isl_multi_val_plain_is_equal(get(), multi2.get());
   return manage(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::project_domain_on_params() const
-{
-  auto res = isl_multi_val_project_domain_on_params(copy());
-  return manage(res);
-}
-
-isl::multi_val multi_val::range_factor_domain() const
-{
-  auto res = isl_multi_val_range_factor_domain(copy());
-  return manage(res);
-}
-
-isl::multi_val multi_val::range_factor_range() const
+isl::multi_val multi_val::range_product(isl::multi_val multi2) const
 {
-  auto res = isl_multi_val_range_factor_range(copy());
+  auto res = isl_multi_val_range_product(copy(), multi2.release());
   return manage(res);
 }
 
-boolean multi_val::range_is_wrapping() const
+isl::id multi_val::range_tuple_id() const
 {
-  auto res = isl_multi_val_range_is_wrapping(get());
+  auto res = isl_multi_val_get_range_tuple_id(get());
   return manage(res);
 }
 
-isl::multi_val multi_val::range_product(isl::multi_val multi2) const
+isl::id multi_val::get_range_tuple_id() const
 {
-  auto res = isl_multi_val_range_product(copy(), multi2.release());
-  return manage(res);
+  return range_tuple_id();
 }
 
-isl::multi_val multi_val::range_splice(unsigned int pos, isl::multi_val multi2) const
+isl::multi_val multi_val::reset_range_tuple_id() const
 {
-  auto res = isl_multi_val_range_splice(copy(), pos, multi2.release());
+  auto res = isl_multi_val_reset_range_tuple_id(copy());
   return manage(res);
 }
 
 isl::multi_val multi_val::reset_tuple_id(isl::dim type) const
 {
   auto res = isl_multi_val_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::multi_val multi_val::reset_user() const
-{
-  auto res = isl_multi_val_reset_user(copy());
-  return manage(res);
-}
-
 isl::multi_val multi_val::scale(isl::multi_val mv) const
 {
   auto res = isl_multi_val_scale_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::scale(isl::val v) const
 {
   auto res = isl_multi_val_scale_val(copy(), v.release());
   return manage(res);
 }
 
+isl::multi_val multi_val::scale(long v) const
+{
+  return this->scale(isl::val(ctx(), v));
+}
+
 isl::multi_val multi_val::scale_down(isl::multi_val mv) const
 {
   auto res = isl_multi_val_scale_down_multi_val(copy(), mv.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::scale_down(isl::val v) const
 {
   auto res = isl_multi_val_scale_down_val(copy(), v.release());
   return manage(res);
 }
 
+isl::multi_val multi_val::scale_down(long v) const
+{
+  return this->scale_down(isl::val(ctx(), v));
+}
+
 isl::multi_val multi_val::set_at(int pos, isl::val el) const
 {
   auto res = isl_multi_val_set_at(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::multi_val multi_val::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::multi_val multi_val::set_at(int pos, long el) const
 {
-  auto res = isl_multi_val_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return this->set_at(pos, isl::val(ctx(), el));
 }
 
-isl::multi_val multi_val::set_tuple_id(isl::dim type, isl::id id) const
+isl::multi_val multi_val::set_range_tuple(isl::id id) const
 {
-  auto res = isl_multi_val_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
+  auto res = isl_multi_val_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::multi_val multi_val::set_tuple_name(isl::dim type, const std::string &s) const
+isl::multi_val multi_val::set_range_tuple(const std::string &id) const
 {
-  auto res = isl_multi_val_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
-  return manage(res);
+  return this->set_range_tuple(isl::id(ctx(), id));
 }
 
 isl::multi_val multi_val::set_val(int pos, isl::val el) const
 {
   auto res = isl_multi_val_set_val(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size multi_val::size() const
+isl::multi_val multi_val::set_val(int pos, long el) const
+{
+  return this->set_val(pos, isl::val(ctx(), el));
+}
+
+class size multi_val::size() const
 {
   auto res = isl_multi_val_size(get());
-  return res;
+  return manage(res);
 }
 
-isl::multi_val multi_val::splice(unsigned int in_pos, unsigned int out_pos, isl::multi_val multi2) const
+isl::space multi_val::space() const
 {
-  auto res = isl_multi_val_splice(copy(), in_pos, out_pos, multi2.release());
+  auto res = isl_multi_val_get_space(get());
   return manage(res);
 }
 
+isl::space multi_val::get_space() const
+{
+  return space();
+}
+
 isl::multi_val multi_val::sub(isl::multi_val multi2) const
 {
   auto res = isl_multi_val_sub(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::zero(isl::space space)
 {
   auto res = isl_multi_val_zero(space.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const multi_val &obj)
+{
+  char *str = isl_multi_val_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::point
 point manage(__isl_take isl_point *ptr) {
   return point(ptr);
 }
 point manage_copy(__isl_keep isl_point *ptr) {
   ptr = isl_point_copy(ptr);
   return point(ptr);
 }
 
 point::point()
     : ptr(nullptr) {}
 
 point::point(const point &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 point::point(__isl_take isl_point *ptr)
     : ptr(ptr) {}
 
-point::point(isl::space dim)
+point::point(isl::space space)
 {
-  auto res = isl_point_zero(dim.release());
+  auto res = isl_point_zero(space.release());
   ptr = res;
 }
 
 point &point::operator=(point obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
__isl_give isl_point *point::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool point::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx point::ctx() const {
   return isl::ctx(isl_point_get_ctx(ptr));
 }
 
-void point::dump() const {
-  isl_point_dump(get());
+isl::set point::add_constraint(const isl::constraint &constraint) const
+{
+  return isl::basic_set(*this).add_constraint(constraint);
 }
 
+isl::set point::add_dims(isl::dim type, unsigned int n) const
+{
+  return isl::basic_set(*this).add_dims(type, n);
+}
 
-isl::point point::add_ui(isl::dim type, int pos, unsigned int val) const
+isl::basic_set point::affine_hull() const
 {
-  auto res = isl_point_add_ui(copy(), static_cast<enum isl_dim_type>(type), pos, val);
-  return manage(res);
+  return isl::basic_set(*this).affine_hull();
 }
 
-isl::val point::get_coordinate_val(isl::dim type, int pos) const
+isl::set point::align_params(const isl::space &model) const
+{
+  return isl::basic_set(*this).align_params(model);
+}
+
+isl::basic_set point::apply(const isl::basic_map &bmap) const
+{
+  return isl::basic_set(*this).apply(bmap);
+}
+
+isl::set point::apply(const isl::map &map) const
+{
+  return isl::basic_set(*this).apply(map);
+}
+
+isl::union_set point::apply(const isl::union_map &umap) const
+{
+  return isl::basic_set(*this).apply(umap);
+}
+
+isl::pw_multi_aff point::as_pw_multi_aff() const
+{
+  return isl::basic_set(*this).as_pw_multi_aff();
+}
+
+isl::set point::as_set() const
+{
+  return isl::basic_set(*this).as_set();
+}
+
+isl::basic_set_list point::basic_set_list() const
+{
+  return isl::basic_set(*this).basic_set_list();
+}
+
+isl::set point::bind(const isl::multi_id &tuple) const
+{
+  return isl::basic_set(*this).bind(tuple);
+}
+
+isl::set point::coalesce() const
+{
+  return isl::basic_set(*this).coalesce();
+}
+
+isl::set point::complement() const
+{
+  return isl::basic_set(*this).complement();
+}
+
+isl::union_set point::compute_divs() const
+{
+  return isl::basic_set(*this).compute_divs();
+}
+
+boolean point::contains(const isl::space &space) const
+{
+  return isl::basic_set(*this).contains(space);
+}
+
+isl::basic_set point::convex_hull() const
+{
+  return isl::basic_set(*this).convex_hull();
+}
+
+isl::val point::coordinate_val(isl::dim type, int pos) const
 {
   auto res = isl_point_get_coordinate_val(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-isl::multi_val point::get_multi_val() const
+isl::val point::get_coordinate_val(isl::dim type, int pos) const
 {
-  auto res = isl_point_get_multi_val(get());
-  return manage(res);
+  return coordinate_val(type, pos);
 }
 
-isl::space point::get_space() const
+isl::basic_set point::detect_equalities() const
 {
-  auto res = isl_point_get_space(get());
-  return manage(res);
+  return isl::basic_set(*this).detect_equalities();
 }
 
-isl::point point::set_coordinate_val(isl::dim type, int pos, isl::val v) const
+class size point::dim(isl::dim type) const
 {
-  auto res = isl_point_set_coordinate_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
-  return manage(res);
+  return isl::basic_set(*this).dim(type);
 }
 
-isl::point point::sub_ui(isl::dim type, int pos, unsigned int val) const
+boolean point::dim_has_any_lower_bound(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_point_sub_ui(copy(), static_cast<enum isl_dim_type>(type), pos, val);
-  return manage(res);
+  return isl::basic_set(*this).dim_has_any_lower_bound(type, pos);
 }
 
-// implementations for isl::pw_aff
-pw_aff manage(__isl_take isl_pw_aff *ptr) {
-  return pw_aff(ptr);
+isl::id point::dim_id(isl::dim type, unsigned int pos) const
+{
+  return isl::basic_set(*this).dim_id(type, pos);
 }
-pw_aff manage_copy(__isl_keep isl_pw_aff *ptr) {
-  ptr = isl_pw_aff_copy(ptr);
-  return pw_aff(ptr);
+
+isl::pw_aff point::dim_max(int pos) const
+{
+  return isl::basic_set(*this).dim_max(pos);
 }
 
-pw_aff::pw_aff()
-    : ptr(nullptr) {}
+isl::val point::dim_max_val(int pos) const
+{
+  return isl::basic_set(*this).dim_max_val(pos);
+}
 
-pw_aff::pw_aff(const pw_aff &obj)
-    : ptr(nullptr)
+isl::pw_aff point::dim_min(int pos) const
 {
-  ptr = obj.copy();
+  return isl::basic_set(*this).dim_min(pos);
 }
 
+isl::val point::dim_min_val(int pos) const
+{
+  return isl::basic_set(*this).dim_min_val(pos);
+}
 
-pw_aff::pw_aff(__isl_take isl_pw_aff *ptr)
-    : ptr(ptr) {}
+std::string point::dim_name(isl::dim type, unsigned int pos) const
+{
+  return isl::basic_set(*this).dim_name(type, pos);
+}
 
-pw_aff::pw_aff(isl::aff aff)
+isl::aff point::div(int pos) const
 {
-  auto res = isl_pw_aff_from_aff(aff.release());
-  ptr = res;
+  return isl::basic_set(*this).div(pos);
 }
-pw_aff::pw_aff(isl::ctx ctx, const std::string &str)
+
+isl::set point::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_aff_read_from_str(ctx.release(), str.c_str());
-  ptr = res;
+  return isl::basic_set(*this).drop_constraints_involving_dims(type, first, n);
 }
-pw_aff::pw_aff(isl::set domain, isl::val v)
+
+isl::set point::eliminate(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_aff_val_on_domain(domain.release(), v.release());
-  ptr = res;
+  return isl::basic_set(*this).eliminate(type, first, n);
 }
-pw_aff::pw_aff(isl::local_space ls)
+
+boolean point::every_set(const std::function<boolean(isl::set)> &test) const
 {
-  auto res = isl_pw_aff_zero_on_domain(ls.release());
-  ptr = res;
+  return isl::basic_set(*this).every_set(test);
 }
 
-pw_aff &pw_aff::operator=(pw_aff obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+isl::set point::extract_set(const isl::space &space) const
+{
+  return isl::basic_set(*this).extract_set(space);
 }
 
-pw_aff::~pw_aff() {
-  if (ptr)
-    isl_pw_aff_free(ptr);
+int point::find_dim_by_id(isl::dim type, const isl::id &id) const
+{
+  return isl::basic_set(*this).find_dim_by_id(type, id);
 }
 
-__isl_give isl_pw_aff *pw_aff::copy() const & {
-  return isl_pw_aff_copy(ptr);
+int point::find_dim_by_id(isl::dim type, const std::string &id) const
+{
+  return this->find_dim_by_id(type, isl::id(ctx(), id));
 }
 
-__isl_keep isl_pw_aff *pw_aff::get() const {
-  return ptr;
+isl::basic_set point::fix_si(isl::dim type, unsigned int pos, int value) const
+{
+  return isl::basic_set(*this).fix_si(type, pos, value);
 }
 
-__isl_give isl_pw_aff *pw_aff::release() {
-  isl_pw_aff *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::basic_set point::fix_val(isl::dim type, unsigned int pos, const isl::val &v) const
+{
+  return isl::basic_set(*this).fix_val(type, pos, v);
 }
 
-bool pw_aff::is_null() const {
-  return ptr == nullptr;
+isl::basic_set point::fix_val(isl::dim type, unsigned int pos, long v) const
+{
+  return this->fix_val(type, pos, isl::val(ctx(), v));
 }
 
+isl::basic_set point::flatten() const
+{
+  return isl::basic_set(*this).flatten();
+}
 
-isl::ctx pw_aff::ctx() const {
-  return isl::ctx(isl_pw_aff_get_ctx(ptr));
+stat point::foreach_basic_set(const std::function<stat(isl::basic_set)> &fn) const
+{
+  return isl::basic_set(*this).foreach_basic_set(fn);
 }
 
-void pw_aff::dump() const {
-  isl_pw_aff_dump(get());
+stat point::foreach_point(const std::function<stat(isl::point)> &fn) const
+{
+  return isl::basic_set(*this).foreach_point(fn);
 }
 
+stat point::foreach_set(const std::function<stat(isl::set)> &fn) const
+{
+  return isl::basic_set(*this).foreach_set(fn);
+}
 
-isl::pw_aff pw_aff::add(isl::pw_aff pwaff2) const
+isl::basic_set point::gist(const isl::basic_set &context) const
 {
-  auto res = isl_pw_aff_add(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).gist(context);
 }
 
-isl::pw_aff pw_aff::add_constant(isl::val v) const
+isl::set point::gist(const isl::set &context) const
 {
-  auto res = isl_pw_aff_add_constant_val(copy(), v.release());
-  return manage(res);
+  return isl::basic_set(*this).gist(context);
 }
 
-isl::pw_aff pw_aff::add_dims(isl::dim type, unsigned int n) const
+isl::union_set point::gist(const isl::union_set &context) const
 {
-  auto res = isl_pw_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return isl::basic_set(*this).gist(context);
 }
 
-isl::pw_aff pw_aff::align_params(isl::space model) const
+isl::set point::gist_params(const isl::set &context) const
 {
-  auto res = isl_pw_aff_align_params(copy(), model.release());
-  return manage(res);
+  return isl::basic_set(*this).gist_params(context);
 }
 
-isl::pw_aff pw_aff::alloc(isl::set set, isl::aff aff)
+boolean point::has_equal_space(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_alloc(set.release(), aff.release());
-  return manage(res);
+  return isl::basic_set(*this).has_equal_space(set2);
 }
 
-isl::aff pw_aff::as_aff() const
+isl::map point::identity() const
 {
-  auto res = isl_pw_aff_as_aff(copy());
-  return manage(res);
+  return isl::basic_set(*this).identity();
 }
 
-isl::set pw_aff::bind(isl::id id) const
+isl::union_pw_multi_aff point::identity_union_pw_multi_aff() const
 {
-  auto res = isl_pw_aff_bind_id(copy(), id.release());
-  return manage(res);
+  return isl::basic_set(*this).identity_union_pw_multi_aff();
 }
 
-isl::pw_aff pw_aff::bind_domain(isl::multi_id tuple) const
+isl::pw_aff point::indicator_function() const
 {
-  auto res = isl_pw_aff_bind_domain(copy(), tuple.release());
-  return manage(res);
+  return isl::basic_set(*this).indicator_function();
 }
 
-isl::pw_aff pw_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+isl::set point::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
 {
-  auto res = isl_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
-  return manage(res);
+  return isl::basic_set(*this).insert_dims(type, pos, n);
 }
 
-isl::pw_aff pw_aff::ceil() const
+isl::map point::insert_domain(const isl::space &domain) const
 {
-  auto res = isl_pw_aff_ceil(copy());
-  return manage(res);
+  return isl::basic_set(*this).insert_domain(domain);
 }
 
-isl::pw_aff pw_aff::coalesce() const
+isl::basic_set point::intersect(const isl::basic_set &bset2) const
 {
-  auto res = isl_pw_aff_coalesce(copy());
-  return manage(res);
+  return isl::basic_set(*this).intersect(bset2);
 }
 
-isl::pw_aff pw_aff::cond(isl::pw_aff pwaff_true, isl::pw_aff pwaff_false) const
+isl::set point::intersect(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_cond(copy(), pwaff_true.release(), pwaff_false.release());
-  return manage(res);
+  return isl::basic_set(*this).intersect(set2);
 }
 
-isl_size pw_aff::dim(isl::dim type) const
+isl::union_set point::intersect(const isl::union_set &uset2) const
 {
-  auto res = isl_pw_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::basic_set(*this).intersect(uset2);
 }
 
-isl::pw_aff pw_aff::div(isl::pw_aff pa2) const
+isl::basic_set point::intersect_params(const isl::basic_set &bset2) const
 {
-  auto res = isl_pw_aff_div(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).intersect_params(bset2);
 }
 
-isl::set pw_aff::domain() const
+isl::set point::intersect_params(const isl::set &params) const
 {
-  auto res = isl_pw_aff_domain(copy());
-  return manage(res);
+  return isl::basic_set(*this).intersect_params(params);
 }
 
-isl::pw_aff pw_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+boolean point::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::basic_set(*this).involves_dims(type, first, n);
 }
 
-isl::pw_aff pw_aff::drop_unused_params() const
+boolean point::involves_locals() const
 {
-  auto res = isl_pw_aff_drop_unused_params(copy());
-  return manage(res);
+  return isl::basic_set(*this).involves_locals();
 }
 
-isl::pw_aff pw_aff::empty(isl::space space)
+boolean point::is_bounded() const
 {
-  auto res = isl_pw_aff_empty(space.release());
-  return manage(res);
+  return isl::basic_set(*this).is_bounded();
 }
 
-isl::map pw_aff::eq_map(isl::pw_aff pa2) const
+boolean point::is_disjoint(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_eq_map(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).is_disjoint(set2);
 }
 
-isl::set pw_aff::eq_set(isl::pw_aff pwaff2) const
+boolean point::is_disjoint(const isl::union_set &uset2) const
 {
-  auto res = isl_pw_aff_eq_set(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).is_disjoint(uset2);
 }
 
-isl::val pw_aff::eval(isl::point pnt) const
+boolean point::is_empty() const
 {
-  auto res = isl_pw_aff_eval(copy(), pnt.release());
-  return manage(res);
+  return isl::basic_set(*this).is_empty();
 }
 
-int pw_aff::find_dim_by_name(isl::dim type, const std::string &name) const
+boolean point::is_equal(const isl::basic_set &bset2) const
 {
-  auto res = isl_pw_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return isl::basic_set(*this).is_equal(bset2);
 }
 
-isl::pw_aff pw_aff::floor() const
+boolean point::is_equal(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_floor(copy());
-  return manage(res);
+  return isl::basic_set(*this).is_equal(set2);
 }
 
-stat pw_aff::foreach_piece(const std::function<stat(set, aff)> &fn) const
+boolean point::is_equal(const isl::union_set &uset2) const
 {
-  struct fn_data {
-    const std::function<stat(set, 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)(manage(arg_0), manage(arg_1));
-    return ret.release();
-  };
-  auto res = isl_pw_aff_foreach_piece(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return isl::basic_set(*this).is_equal(uset2);
 }
 
-isl::pw_aff pw_aff::from_range() const
+boolean point::is_params() const
 {
-  auto res = isl_pw_aff_from_range(copy());
-  return manage(res);
+  return isl::basic_set(*this).is_params();
 }
 
-isl::map pw_aff::ge_map(isl::pw_aff pa2) const
+boolean point::is_singleton() const
 {
-  auto res = isl_pw_aff_ge_map(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).is_singleton();
 }
 
-isl::set pw_aff::ge_set(isl::pw_aff pwaff2) const
+boolean point::is_strict_subset(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_ge_set(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).is_strict_subset(set2);
 }
 
-isl::id pw_aff::get_dim_id(isl::dim type, unsigned int pos) const
+boolean point::is_strict_subset(const isl::union_set &uset2) const
 {
-  auto res = isl_pw_aff_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::basic_set(*this).is_strict_subset(uset2);
 }
 
-std::string pw_aff::get_dim_name(isl::dim type, unsigned int pos) const
+boolean point::is_subset(const isl::basic_set &bset2) const
 {
-  auto res = isl_pw_aff_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return isl::basic_set(*this).is_subset(bset2);
 }
 
-isl::space pw_aff::get_domain_space() const
+boolean point::is_subset(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_get_domain_space(get());
-  return manage(res);
+  return isl::basic_set(*this).is_subset(set2);
 }
 
-uint32_t pw_aff::get_hash() const
+boolean point::is_subset(const isl::union_set &uset2) const
 {
-  auto res = isl_pw_aff_get_hash(get());
-  return res;
+  return isl::basic_set(*this).is_subset(uset2);
 }
 
-isl::space pw_aff::get_space() const
+boolean point::is_wrapping() const
 {
-  auto res = isl_pw_aff_get_space(get());
-  return manage(res);
+  return isl::basic_set(*this).is_wrapping();
 }
 
-isl::id pw_aff::get_tuple_id(isl::dim type) const
+boolean point::isa_set() const
 {
-  auto res = isl_pw_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::basic_set(*this).isa_set();
 }
 
-isl::pw_aff pw_aff::gist(isl::set context) const
+isl::set point::lexmax() const
 {
-  auto res = isl_pw_aff_gist(copy(), context.release());
-  return manage(res);
+  return isl::basic_set(*this).lexmax();
 }
 
-isl::pw_aff pw_aff::gist_params(isl::set context) const
+isl::pw_multi_aff point::lexmax_pw_multi_aff() const
 {
-  auto res = isl_pw_aff_gist_params(copy(), context.release());
-  return manage(res);
+  return isl::basic_set(*this).lexmax_pw_multi_aff();
 }
 
-isl::map pw_aff::gt_map(isl::pw_aff pa2) const
+isl::set point::lexmin() const
 {
-  auto res = isl_pw_aff_gt_map(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).lexmin();
 }
 
-isl::set pw_aff::gt_set(isl::pw_aff pwaff2) const
+isl::pw_multi_aff point::lexmin_pw_multi_aff() const
 {
-  auto res = isl_pw_aff_gt_set(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).lexmin_pw_multi_aff();
 }
 
-boolean pw_aff::has_dim_id(isl::dim type, unsigned int pos) const
+isl::set point::lower_bound(const isl::multi_pw_aff &lower) const
 {
-  auto res = isl_pw_aff_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::basic_set(*this).lower_bound(lower);
 }
 
-boolean pw_aff::has_tuple_id(isl::dim type) const
+isl::set point::lower_bound(const isl::multi_val &lower) const
 {
-  auto res = isl_pw_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::basic_set(*this).lower_bound(lower);
 }
 
-isl::pw_aff pw_aff::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::set point::lower_bound_si(isl::dim type, unsigned int pos, int value) const
 {
-  auto res = isl_pw_aff_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::basic_set(*this).lower_bound_si(type, pos, value);
 }
 
-isl::pw_aff pw_aff::insert_domain(isl::space domain) const
+isl::set point::lower_bound_val(isl::dim type, unsigned int pos, const isl::val &value) const
 {
-  auto res = isl_pw_aff_insert_domain(copy(), domain.release());
-  return manage(res);
+  return isl::basic_set(*this).lower_bound_val(type, pos, value);
 }
 
-isl::pw_aff pw_aff::intersect_domain(isl::set set) const
+isl::set point::lower_bound_val(isl::dim type, unsigned int pos, long value) const
 {
-  auto res = isl_pw_aff_intersect_domain(copy(), set.release());
-  return manage(res);
+  return this->lower_bound_val(type, pos, isl::val(ctx(), value));
 }
 
-isl::pw_aff pw_aff::intersect_domain_wrapped_domain(isl::set set) const
+isl::multi_pw_aff point::max_multi_pw_aff() const
 {
-  auto res = isl_pw_aff_intersect_domain_wrapped_domain(copy(), set.release());
-  return manage(res);
+  return isl::basic_set(*this).max_multi_pw_aff();
 }
 
-isl::pw_aff pw_aff::intersect_domain_wrapped_range(isl::set set) const
+isl::val point::max_val(const isl::aff &obj) const
 {
-  auto res = isl_pw_aff_intersect_domain_wrapped_range(copy(), set.release());
-  return manage(res);
+  return isl::basic_set(*this).max_val(obj);
 }
 
-isl::pw_aff pw_aff::intersect_params(isl::set set) const
+isl::multi_pw_aff point::min_multi_pw_aff() const
 {
-  auto res = isl_pw_aff_intersect_params(copy(), set.release());
-  return manage(res);
+  return isl::basic_set(*this).min_multi_pw_aff();
 }
 
-boolean pw_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::val point::min_val(const isl::aff &obj) const
 {
-  auto res = isl_pw_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::basic_set(*this).min_val(obj);
 }
 
-boolean pw_aff::involves_nan() const
+isl::multi_val point::multi_val() const
 {
-  auto res = isl_pw_aff_involves_nan(get());
+  auto res = isl_point_get_multi_val(get());
   return manage(res);
 }
 
-boolean pw_aff::involves_param_id(const isl::id &id) const
+isl::multi_val point::get_multi_val() const
 {
-  auto res = isl_pw_aff_involves_param_id(get(), id.get());
-  return manage(res);
+  return multi_val();
 }
 
-boolean pw_aff::is_cst() const
+class size point::n_basic_set() const
 {
-  auto res = isl_pw_aff_is_cst(get());
-  return manage(res);
+  return isl::basic_set(*this).n_basic_set();
 }
 
-boolean pw_aff::is_empty() const
+isl::basic_set point::params() const
 {
-  auto res = isl_pw_aff_is_empty(get());
-  return manage(res);
+  return isl::basic_set(*this).params();
 }
 
-boolean pw_aff::is_equal(const isl::pw_aff &pa2) const
+isl::val point::plain_get_val_if_fixed(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_pw_aff_is_equal(get(), pa2.get());
-  return manage(res);
+  return isl::basic_set(*this).plain_get_val_if_fixed(type, pos);
 }
 
-boolean pw_aff::isa_aff() const
+isl::multi_val point::plain_multi_val_if_fixed() const
 {
-  auto res = isl_pw_aff_isa_aff(get());
-  return manage(res);
+  return isl::basic_set(*this).plain_multi_val_if_fixed();
 }
 
-isl::map pw_aff::le_map(isl::pw_aff pa2) const
+isl::basic_set point::polyhedral_hull() const
 {
-  auto res = isl_pw_aff_le_map(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).polyhedral_hull();
 }
 
-isl::set pw_aff::le_set(isl::pw_aff pwaff2) const
+isl::set point::preimage(const isl::multi_aff &ma) const
 {
-  auto res = isl_pw_aff_le_set(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).preimage(ma);
 }
 
-isl::map pw_aff::lt_map(isl::pw_aff pa2) const
+isl::set point::preimage(const isl::multi_pw_aff &mpa) const
 {
-  auto res = isl_pw_aff_lt_map(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).preimage(mpa);
 }
 
-isl::set pw_aff::lt_set(isl::pw_aff pwaff2) const
+isl::set point::preimage(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_pw_aff_lt_set(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).preimage(pma);
 }
 
-isl::pw_aff pw_aff::max(isl::pw_aff pwaff2) const
+isl::union_set point::preimage(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_pw_aff_max(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).preimage(upma);
 }
 
-isl::pw_aff pw_aff::min(isl::pw_aff pwaff2) const
+isl::set point::product(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_min(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).product(set2);
 }
 
-isl::pw_aff pw_aff::mod(isl::val mod) const
+isl::basic_set point::project_out(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_aff_mod_val(copy(), mod.release());
-  return manage(res);
+  return isl::basic_set(*this).project_out(type, first, n);
 }
 
-isl::pw_aff pw_aff::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::set point::project_out_all_params() const
 {
-  auto res = isl_pw_aff_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);
+  return isl::basic_set(*this).project_out_all_params();
 }
 
-isl::pw_aff pw_aff::mul(isl::pw_aff pwaff2) const
+isl::set point::project_out_param(const isl::id &id) const
 {
-  auto res = isl_pw_aff_mul(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).project_out_param(id);
 }
 
-isl_size pw_aff::n_piece() const
+isl::set point::project_out_param(const std::string &id) const
 {
-  auto res = isl_pw_aff_n_piece(get());
-  return res;
+  return this->project_out_param(isl::id(ctx(), id));
 }
 
-isl::pw_aff pw_aff::nan_on_domain(isl::local_space ls)
+isl::set point::project_out_param(const isl::id_list &list) const
 {
-  auto res = isl_pw_aff_nan_on_domain(ls.release());
-  return manage(res);
+  return isl::basic_set(*this).project_out_param(list);
 }
 
-isl::pw_aff pw_aff::nan_on_domain_space(isl::space space)
+isl::pw_multi_aff point::pw_multi_aff_on_domain(const isl::multi_val &mv) const
 {
-  auto res = isl_pw_aff_nan_on_domain_space(space.release());
-  return manage(res);
+  return isl::basic_set(*this).pw_multi_aff_on_domain(mv);
 }
 
-isl::set pw_aff::ne_set(isl::pw_aff pwaff2) const
+isl::set point::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_aff_ne_set(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).remove_dims(type, first, n);
 }
 
-isl::pw_aff pw_aff::neg() const
+isl::set point::remove_divs() const
 {
-  auto res = isl_pw_aff_neg(copy());
-  return manage(res);
+  return isl::basic_set(*this).remove_divs();
 }
 
-isl::set pw_aff::non_zero_set() const
+isl::set point::remove_redundancies() const
 {
-  auto res = isl_pw_aff_non_zero_set(copy());
-  return manage(res);
+  return isl::basic_set(*this).remove_redundancies();
 }
 
-isl::set pw_aff::nonneg_set() const
+isl::set point::reset_tuple_id() const
 {
-  auto res = isl_pw_aff_nonneg_set(copy());
-  return manage(res);
+  return isl::basic_set(*this).reset_tuple_id();
 }
 
-isl::pw_aff pw_aff::param_on_domain(isl::set domain, isl::id id)
+isl::basic_set point::sample() const
 {
-  auto res = isl_pw_aff_param_on_domain_id(domain.release(), id.release());
-  return manage(res);
+  return isl::basic_set(*this).sample();
 }
 
-isl::set pw_aff::params() const
+isl::point point::sample_point() const
 {
-  auto res = isl_pw_aff_params(copy());
-  return manage(res);
+  return isl::basic_set(*this).sample_point();
 }
 
-int pw_aff::plain_cmp(const isl::pw_aff &pa2) const
+isl::set point::set_dim_id(isl::dim type, unsigned int pos, const isl::id &id) const
 {
-  auto res = isl_pw_aff_plain_cmp(get(), pa2.get());
-  return res;
+  return isl::basic_set(*this).set_dim_id(type, pos, id);
 }
 
-boolean pw_aff::plain_is_equal(const isl::pw_aff &pwaff2) const
+isl::set point::set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const
 {
-  auto res = isl_pw_aff_plain_is_equal(get(), pwaff2.get());
-  return manage(res);
+  return this->set_dim_id(type, pos, isl::id(ctx(), id));
 }
 
-isl::set pw_aff::pos_set() const
+isl::set_list point::set_list() const
 {
-  auto res = isl_pw_aff_pos_set(copy());
-  return manage(res);
+  return isl::basic_set(*this).set_list();
 }
 
-isl::pw_aff pw_aff::project_domain_on_params() const
+isl::set point::set_tuple_id(const isl::id &id) const
 {
-  auto res = isl_pw_aff_project_domain_on_params(copy());
-  return manage(res);
+  return isl::basic_set(*this).set_tuple_id(id);
 }
 
-isl::pw_aff pw_aff::pullback(isl::multi_aff ma) const
+isl::set point::set_tuple_id(const std::string &id) const
 {
-  auto res = isl_pw_aff_pullback_multi_aff(copy(), ma.release());
-  return manage(res);
+  return this->set_tuple_id(isl::id(ctx(), id));
 }
 
-isl::pw_aff pw_aff::pullback(isl::multi_pw_aff mpa) const
+isl::fixed_box point::simple_fixed_box_hull() const
 {
-  auto res = isl_pw_aff_pullback_multi_pw_aff(copy(), mpa.release());
-  return manage(res);
+  return isl::basic_set(*this).simple_fixed_box_hull();
 }
 
-isl::pw_aff pw_aff::pullback(isl::pw_multi_aff pma) const
+isl::basic_set point::simple_hull() const
 {
-  auto res = isl_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
-  return manage(res);
+  return isl::basic_set(*this).simple_hull();
 }
 
-isl::pw_aff pw_aff::reset_tuple_id(isl::dim type) const
+isl::space point::space() const
 {
-  auto res = isl_pw_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::basic_set(*this).space();
 }
 
-isl::pw_aff pw_aff::reset_user() const
+isl::val point::stride(int pos) const
 {
-  auto res = isl_pw_aff_reset_user(copy());
-  return manage(res);
+  return isl::basic_set(*this).stride(pos);
 }
 
-isl::pw_aff pw_aff::scale(isl::val v) const
+isl::set point::subtract(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_scale_val(copy(), v.release());
-  return manage(res);
+  return isl::basic_set(*this).subtract(set2);
 }
 
-isl::pw_aff pw_aff::scale_down(isl::val f) const
+isl::union_set point::subtract(const isl::union_set &uset2) const
 {
-  auto res = isl_pw_aff_scale_down_val(copy(), f.release());
-  return manage(res);
+  return isl::basic_set(*this).subtract(uset2);
 }
 
-isl::pw_aff pw_aff::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::basic_set_list point::to_list() const
 {
-  auto res = isl_pw_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return isl::basic_set(*this).to_list();
 }
 
-isl::pw_aff pw_aff::set_tuple_id(isl::dim type, isl::id id) const
+isl::set point::to_set() const
 {
-  auto res = isl_pw_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
+  auto res = isl_point_to_set(copy());
   return manage(res);
 }
 
-isl::pw_aff pw_aff::sub(isl::pw_aff pwaff2) const
+isl::union_set point::to_union_set() const
 {
-  auto res = isl_pw_aff_sub(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).to_union_set();
 }
 
-isl::pw_aff pw_aff::subtract_domain(isl::set set) const
+isl::map point::translation() const
 {
-  auto res = isl_pw_aff_subtract_domain(copy(), set.release());
-  return manage(res);
+  return isl::basic_set(*this).translation();
 }
 
-isl::pw_aff pw_aff::tdiv_q(isl::pw_aff pa2) const
+class size point::tuple_dim() const
 {
-  auto res = isl_pw_aff_tdiv_q(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).tuple_dim();
 }
 
-isl::pw_aff pw_aff::tdiv_r(isl::pw_aff pa2) const
+isl::id point::tuple_id() const
 {
-  auto res = isl_pw_aff_tdiv_r(copy(), pa2.release());
-  return manage(res);
+  return isl::basic_set(*this).tuple_id();
 }
 
-isl::pw_aff pw_aff::union_add(isl::pw_aff pwaff2) const
+std::string point::tuple_name() const
 {
-  auto res = isl_pw_aff_union_add(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).tuple_name();
 }
 
-isl::pw_aff pw_aff::union_max(isl::pw_aff pwaff2) const
+isl::set point::unbind_params(const isl::multi_id &tuple) const
 {
-  auto res = isl_pw_aff_union_max(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).unbind_params(tuple);
 }
 
-isl::pw_aff pw_aff::union_min(isl::pw_aff pwaff2) const
+isl::map point::unbind_params_insert_domain(const isl::multi_id &domain) const
 {
-  auto res = isl_pw_aff_union_min(copy(), pwaff2.release());
-  return manage(res);
+  return isl::basic_set(*this).unbind_params_insert_domain(domain);
 }
 
-isl::pw_aff pw_aff::var_on_domain(isl::local_space ls, isl::dim type, unsigned int pos)
+isl::set point::unite(const isl::basic_set &bset2) const
 {
-  auto res = isl_pw_aff_var_on_domain(ls.release(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return isl::basic_set(*this).unite(bset2);
 }
 
-isl::set pw_aff::zero_set() const
+isl::set point::unite(const isl::set &set2) const
 {
-  auto res = isl_pw_aff_zero_set(copy());
-  return manage(res);
+  return isl::basic_set(*this).unite(set2);
 }
 
-// implementations for isl::pw_aff_list
-pw_aff_list manage(__isl_take isl_pw_aff_list *ptr) {
-  return pw_aff_list(ptr);
+isl::union_set point::unite(const isl::union_set &uset2) const
+{
+  return isl::basic_set(*this).unite(uset2);
 }
-pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr) {
-  ptr = isl_pw_aff_list_copy(ptr);
-  return pw_aff_list(ptr);
+
+isl::basic_set point::unshifted_simple_hull() const
+{
+  return isl::basic_set(*this).unshifted_simple_hull();
 }
 
-pw_aff_list::pw_aff_list()
+isl::map point::unwrap() const
+{
+  return isl::basic_set(*this).unwrap();
+}
+
+isl::set point::upper_bound(const isl::multi_pw_aff &upper) const
+{
+  return isl::basic_set(*this).upper_bound(upper);
+}
+
+isl::set point::upper_bound(const isl::multi_val &upper) const
+{
+  return isl::basic_set(*this).upper_bound(upper);
+}
+
+isl::set point::upper_bound_val(isl::dim type, unsigned int pos, const isl::val &value) const
+{
+  return isl::basic_set(*this).upper_bound_val(type, pos, value);
+}
+
+isl::set point::upper_bound_val(isl::dim type, unsigned int pos, long value) const
+{
+  return this->upper_bound_val(type, pos, isl::val(ctx(), value));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const point &obj)
+{
+  char *str = isl_point_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::pw_aff
+pw_aff manage(__isl_take isl_pw_aff *ptr) {
+  return pw_aff(ptr);
+}
+pw_aff manage_copy(__isl_keep isl_pw_aff *ptr) {
+  ptr = isl_pw_aff_copy(ptr);
+  return pw_aff(ptr);
+}
+
+pw_aff::pw_aff()
     : ptr(nullptr) {}
 
-pw_aff_list::pw_aff_list(const pw_aff_list &obj)
+pw_aff::pw_aff(const pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
-pw_aff_list::pw_aff_list(__isl_take isl_pw_aff_list *ptr)
+pw_aff::pw_aff(__isl_take isl_pw_aff *ptr)
     : ptr(ptr) {}
 
+pw_aff::pw_aff(isl::aff aff)
+{
+  auto res = isl_pw_aff_from_aff(aff.release());
+  ptr = res;
+}
+
+pw_aff::pw_aff(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_pw_aff_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
-pw_aff_list &pw_aff_list::operator=(pw_aff_list obj) {
+pw_aff::pw_aff(isl::set domain, isl::val v)
+{
+  auto res = isl_pw_aff_val_on_domain(domain.release(), v.release());
+  ptr = res;
+}
+
+pw_aff::pw_aff(isl::local_space ls)
+{
+  auto res = isl_pw_aff_zero_on_domain(ls.release());
+  ptr = res;
+}
+
+pw_aff &pw_aff::operator=(pw_aff obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
-pw_aff_list::~pw_aff_list() {
+pw_aff::~pw_aff() {
   if (ptr)
-    isl_pw_aff_list_free(ptr);
+    isl_pw_aff_free(ptr);
 }
 
-__isl_give isl_pw_aff_list *pw_aff_list::copy() const & {
-  return isl_pw_aff_list_copy(ptr);
+__isl_give isl_pw_aff *pw_aff::copy() const & {
+  return isl_pw_aff_copy(ptr);
 }
 
-__isl_keep isl_pw_aff_list *pw_aff_list::get() const {
+__isl_keep isl_pw_aff *pw_aff::get() const {
   return ptr;
 }
 
-__isl_give isl_pw_aff_list *pw_aff_list::release() {
-  isl_pw_aff_list *tmp = ptr;
+__isl_give isl_pw_aff *pw_aff::release() {
+  isl_pw_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
-bool pw_aff_list::is_null() const {
+bool pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
-
-isl::ctx pw_aff_list::ctx() const {
-  return isl::ctx(isl_pw_aff_list_get_ctx(ptr));
+isl::ctx pw_aff::ctx() const {
+  return isl::ctx(isl_pw_aff_get_ctx(ptr));
 }
 
-void pw_aff_list::dump() const {
-  isl_pw_aff_list_dump(get());
+isl::multi_pw_aff pw_aff::add(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_multi_aff(*this).add(multi2);
 }
 
+isl::multi_union_pw_aff pw_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::union_pw_aff(*this).add(multi2);
+}
 
-isl::pw_aff_list pw_aff_list::add(isl::pw_aff el) const
+isl::pw_aff pw_aff::add(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_aff_list_add(copy(), el.release());
+  auto res = isl_pw_aff_add(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl::pw_aff_list pw_aff_list::alloc(isl::ctx ctx, int n)
+isl::pw_multi_aff pw_aff::add(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_pw_aff_list_alloc(ctx.release(), n);
-  return manage(res);
+  return isl::pw_multi_aff(*this).add(pma2);
 }
 
-isl::pw_aff_list pw_aff_list::clear() const
+isl::union_pw_aff pw_aff::add(const isl::union_pw_aff &upa2) const
 {
-  auto res = isl_pw_aff_list_clear(copy());
-  return manage(res);
+  return isl::union_pw_aff(*this).add(upa2);
 }
 
-isl::pw_aff_list pw_aff_list::concat(isl::pw_aff_list list2) const
+isl::union_pw_multi_aff pw_aff::add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_aff_list_concat(copy(), list2.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).add(upma2);
 }
 
-isl::pw_aff_list pw_aff_list::drop(unsigned int first, unsigned int n) const
+isl::pw_aff pw_aff::add(const isl::aff &pwaff2) const
 {
-  auto res = isl_pw_aff_list_drop(copy(), first, n);
-  return manage(res);
+  return this->add(isl::pw_aff(pwaff2));
 }
 
-isl::set pw_aff_list::eq_set(isl::pw_aff_list list2) const
+isl::pw_aff pw_aff::add_constant(isl::val v) const
 {
-  auto res = isl_pw_aff_list_eq_set(copy(), list2.release());
+  auto res = isl_pw_aff_add_constant_val(copy(), v.release());
   return manage(res);
 }
 
-stat pw_aff_list::foreach(const std::function<stat(pw_aff)> &fn) const
+isl::pw_aff pw_aff::add_constant(long v) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_pw_aff_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return this->add_constant(isl::val(ctx(), v));
 }
 
-isl::pw_aff_list pw_aff_list::from_pw_aff(isl::pw_aff el)
+isl::pw_multi_aff pw_aff::add_constant(const isl::multi_val &mv) const
 {
-  auto res = isl_pw_aff_list_from_pw_aff(el.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).add_constant(mv);
 }
 
-isl::set pw_aff_list::ge_set(isl::pw_aff_list list2) const
+isl::pw_aff pw_aff::add_dims(isl::dim type, unsigned int n) const
 {
-  auto res = isl_pw_aff_list_ge_set(copy(), list2.release());
+  auto res = isl_pw_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
 }
 
-isl::pw_aff pw_aff_list::get_at(int index) const
+isl::union_pw_multi_aff pw_aff::add_pw_multi_aff(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_pw_aff_list_get_at(get(), index);
-  return manage(res);
+  return isl::union_pw_aff(*this).add_pw_multi_aff(pma);
 }
 
-isl::pw_aff pw_aff_list::get_pw_aff(int index) const
+isl::union_pw_multi_aff pw_aff::apply(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_aff_list_get_pw_aff(get(), index);
-  return manage(res);
+  return isl::union_pw_aff(*this).apply(upma2);
 }
 
-isl::set pw_aff_list::gt_set(isl::pw_aff_list list2) const
+isl::aff pw_aff::as_aff() const
 {
-  auto res = isl_pw_aff_list_gt_set(copy(), list2.release());
+  auto res = isl_pw_aff_as_aff(copy());
   return manage(res);
 }
 
-isl::pw_aff_list pw_aff_list::insert(unsigned int pos, isl::pw_aff el) const
+isl::map pw_aff::as_map() const
 {
-  auto res = isl_pw_aff_list_insert(copy(), pos, el.release());
+  auto res = isl_pw_aff_as_map(copy());
   return manage(res);
 }
 
-isl::set pw_aff_list::le_set(isl::pw_aff_list list2) const
+isl::multi_aff pw_aff::as_multi_aff() const
 {
-  auto res = isl_pw_aff_list_le_set(copy(), list2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).as_multi_aff();
 }
 
-isl::set pw_aff_list::lt_set(isl::pw_aff_list list2) const
+isl::multi_union_pw_aff pw_aff::as_multi_union_pw_aff() const
 {
-  auto res = isl_pw_aff_list_lt_set(copy(), list2.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).as_multi_union_pw_aff();
 }
 
-isl::pw_aff pw_aff_list::max() const
+isl::pw_multi_aff pw_aff::as_pw_multi_aff() const
 {
-  auto res = isl_pw_aff_list_max(copy());
-  return manage(res);
+  return isl::union_pw_aff(*this).as_pw_multi_aff();
 }
 
-isl::pw_aff pw_aff_list::min() const
+isl::set pw_aff::as_set() const
 {
-  auto res = isl_pw_aff_list_min(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).as_set();
 }
 
-isl_size pw_aff_list::n_pw_aff() const
+isl::union_map pw_aff::as_union_map() const
 {
-  auto res = isl_pw_aff_list_n_pw_aff(get());
-  return res;
+  return isl::union_pw_aff(*this).as_union_map();
 }
 
-isl::set pw_aff_list::ne_set(isl::pw_aff_list list2) const
+isl::pw_aff pw_aff::at(int pos) const
 {
-  auto res = isl_pw_aff_list_ne_set(copy(), list2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).at(pos);
 }
 
-isl::pw_aff_list pw_aff_list::reverse() const
+isl::set pw_aff::bind(const isl::multi_id &tuple) const
 {
-  auto res = isl_pw_aff_list_reverse(copy());
-  return manage(res);
+  return isl::multi_pw_aff(*this).bind(tuple);
 }
 
-isl::pw_aff_list pw_aff_list::set_pw_aff(int index, isl::pw_aff el) const
+isl::set pw_aff::bind(isl::id id) const
 {
-  auto res = isl_pw_aff_list_set_pw_aff(copy(), index, el.release());
+  auto res = isl_pw_aff_bind_id(copy(), id.release());
   return manage(res);
 }
 
-isl_size pw_aff_list::size() const
+isl::set pw_aff::bind(const std::string &id) const
 {
-  auto res = isl_pw_aff_list_size(get());
-  return res;
+  return this->bind(isl::id(ctx(), id));
 }
 
-isl::pw_aff_list pw_aff_list::swap(unsigned int pos1, unsigned int pos2) const
+isl::pw_aff pw_aff::bind_domain(isl::multi_id tuple) const
 {
-  auto res = isl_pw_aff_list_swap(copy(), pos1, pos2);
+  auto res = isl_pw_aff_bind_domain(copy(), tuple.release());
   return manage(res);
 }
 
-// implementations for isl::pw_multi_aff
-pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr) {
-  return pw_multi_aff(ptr);
+isl::pw_aff pw_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+{
+  auto res = isl_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  return manage(res);
 }
-pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr) {
-  ptr = isl_pw_multi_aff_copy(ptr);
-  return pw_multi_aff(ptr);
+
+isl::pw_aff pw_aff::ceil() const
+{
+  auto res = isl_pw_aff_ceil(copy());
+  return manage(res);
 }
 
-pw_multi_aff::pw_multi_aff()
-    : ptr(nullptr) {}
+isl::pw_aff pw_aff::coalesce() const
+{
+  auto res = isl_pw_aff_coalesce(copy());
+  return manage(res);
+}
 
-pw_multi_aff::pw_multi_aff(const pw_multi_aff &obj)
-    : ptr(nullptr)
+isl::pw_aff pw_aff::cond(isl::pw_aff pwaff_true, isl::pw_aff pwaff_false) const
 {
-  ptr = obj.copy();
+  auto res = isl_pw_aff_cond(copy(), pwaff_true.release(), pwaff_false.release());
+  return manage(res);
 }
 
+class size pw_aff::dim(isl::dim type) const
+{
+  return isl::pw_multi_aff(*this).dim(type);
+}
 
-pw_multi_aff::pw_multi_aff(__isl_take isl_pw_multi_aff *ptr)
-    : ptr(ptr) {}
+isl::id pw_aff::dim_id(isl::dim type, unsigned int pos) const
+{
+  auto res = isl_pw_aff_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
+  return manage(res);
+}
 
-pw_multi_aff::pw_multi_aff(isl::multi_aff ma)
+isl::id pw_aff::get_dim_id(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_pw_multi_aff_from_multi_aff(ma.release());
-  ptr = res;
+  return dim_id(type, pos);
 }
-pw_multi_aff::pw_multi_aff(isl::pw_aff pa)
+
+isl::pw_aff pw_aff::div(isl::pw_aff pa2) const
 {
-  auto res = isl_pw_multi_aff_from_pw_aff(pa.release());
-  ptr = res;
+  auto res = isl_pw_aff_div(copy(), pa2.release());
+  return manage(res);
 }
-pw_multi_aff::pw_multi_aff(isl::ctx ctx, const std::string &str)
+
+isl::set pw_aff::domain() const
 {
-  auto res = isl_pw_multi_aff_read_from_str(ctx.release(), str.c_str());
-  ptr = res;
+  auto res = isl_pw_aff_domain(copy());
+  return manage(res);
 }
 
-pw_multi_aff &pw_multi_aff::operator=(pw_multi_aff obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+isl::space pw_aff::domain_space() const
+{
+  auto res = isl_pw_aff_get_domain_space(get());
+  return manage(res);
 }
 
-pw_multi_aff::~pw_multi_aff() {
-  if (ptr)
-    isl_pw_multi_aff_free(ptr);
+isl::space pw_aff::get_domain_space() const
+{
+  return domain_space();
 }
 
-__isl_give isl_pw_multi_aff *pw_multi_aff::copy() const & {
-  return isl_pw_multi_aff_copy(ptr);
+isl::pw_multi_aff pw_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+{
+  return isl::pw_multi_aff(*this).drop_dims(type, first, n);
 }
 
-__isl_keep isl_pw_multi_aff *pw_multi_aff::get() const {
-  return ptr;
+isl::set pw_aff::eq_set(isl::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_eq_set(copy(), pwaff2.release());
+  return manage(res);
 }
 
-__isl_give isl_pw_multi_aff *pw_multi_aff::release() {
-  isl_pw_multi_aff *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::val pw_aff::eval(isl::point pnt) const
+{
+  auto res = isl_pw_aff_eval(copy(), pnt.release());
+  return manage(res);
 }
 
-bool pw_multi_aff::is_null() const {
-  return ptr == nullptr;
+isl::pw_multi_aff pw_aff::extract_pw_multi_aff(const isl::space &space) const
+{
+  return isl::union_pw_aff(*this).extract_pw_multi_aff(space);
 }
 
+isl::multi_pw_aff pw_aff::flat_range_product(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_multi_aff(*this).flat_range_product(multi2);
+}
 
-isl::ctx pw_multi_aff::ctx() const {
-  return isl::ctx(isl_pw_multi_aff_get_ctx(ptr));
+isl::multi_union_pw_aff pw_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::union_pw_aff(*this).flat_range_product(multi2);
 }
 
-void pw_multi_aff::dump() const {
-  isl_pw_multi_aff_dump(get());
+isl::pw_multi_aff pw_aff::flat_range_product(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_multi_aff(*this).flat_range_product(pma2);
 }
 
+isl::union_pw_multi_aff pw_aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_aff(*this).flat_range_product(upma2);
+}
 
-isl::pw_multi_aff pw_multi_aff::add(isl::pw_multi_aff pma2) const
+isl::pw_aff pw_aff::floor() const
 {
-  auto res = isl_pw_multi_aff_add(copy(), pma2.release());
+  auto res = isl_pw_aff_floor(copy());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::add_constant(isl::multi_val mv) const
+stat pw_aff::foreach_piece(const std::function<stat(isl::set, isl::aff)> &fn) const
 {
-  auto res = isl_pw_multi_aff_add_constant_multi_val(copy(), mv.release());
+  struct fn_data {
+    std::function<stat(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);
+    auto ret = (data->func)(manage(arg_0), manage(arg_1));
+    return ret.release();
+  };
+  auto res = isl_pw_aff_foreach_piece(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::add_constant(isl::val v) const
+stat pw_aff::foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const
 {
-  auto res = isl_pw_multi_aff_add_constant_val(copy(), v.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).foreach_piece(fn);
 }
 
-isl::pw_multi_aff pw_multi_aff::align_params(isl::space model) const
+stat pw_aff::foreach_pw_aff(const std::function<stat(isl::pw_aff)> &fn) const
 {
-  auto res = isl_pw_multi_aff_align_params(copy(), model.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).foreach_pw_aff(fn);
 }
 
-isl::pw_multi_aff pw_multi_aff::alloc(isl::set set, isl::multi_aff maff)
+isl::set pw_aff::ge_set(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_alloc(set.release(), maff.release());
+  auto res = isl_pw_aff_ge_set(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl::multi_aff pw_multi_aff::as_multi_aff() const
+isl::pw_aff pw_aff::gist(isl::set context) const
 {
-  auto res = isl_pw_multi_aff_as_multi_aff(copy());
+  auto res = isl_pw_aff_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::bind_domain(isl::multi_id tuple) const
+isl::union_pw_aff pw_aff::gist(const isl::union_set &context) const
 {
-  auto res = isl_pw_multi_aff_bind_domain(copy(), tuple.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).gist(context);
 }
 
-isl::pw_multi_aff pw_multi_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+isl::pw_aff pw_aff::gist(const isl::basic_set &context) const
 {
-  auto res = isl_pw_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
-  return manage(res);
+  return this->gist(isl::set(context));
 }
 
-isl::pw_multi_aff pw_multi_aff::coalesce() const
+isl::pw_aff pw_aff::gist(const isl::point &context) const
 {
-  auto res = isl_pw_multi_aff_coalesce(copy());
+  return this->gist(isl::set(context));
+}
+
+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_size pw_multi_aff::dim(isl::dim type) const
+boolean pw_aff::has_range_tuple_id() const
 {
-  auto res = isl_pw_multi_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::pw_multi_aff(*this).has_range_tuple_id();
 }
 
-isl::set pw_multi_aff::domain() const
+isl::multi_pw_aff pw_aff::identity() const
 {
-  auto res = isl_pw_multi_aff_domain(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).identity();
 }
 
-isl::pw_multi_aff pw_multi_aff::domain_map(isl::space space)
+isl::pw_aff pw_aff::insert_domain(isl::space domain) const
 {
-  auto res = isl_pw_multi_aff_domain_map(space.release());
+  auto res = isl_pw_aff_insert_domain(copy(), domain.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::pw_aff pw_aff::intersect_domain(isl::set set) const
 {
-  auto res = isl_pw_multi_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_pw_aff_intersect_domain(copy(), set.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::drop_unused_params() const
+isl::union_pw_aff pw_aff::intersect_domain(const isl::space &space) const
 {
-  auto res = isl_pw_multi_aff_drop_unused_params(copy());
-  return manage(res);
+  return isl::union_pw_aff(*this).intersect_domain(space);
 }
 
-isl::pw_multi_aff pw_multi_aff::empty(isl::space space)
+isl::union_pw_aff pw_aff::intersect_domain(const isl::union_set &uset) const
 {
-  auto res = isl_pw_multi_aff_empty(space.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).intersect_domain(uset);
 }
 
-int pw_multi_aff::find_dim_by_name(isl::dim type, const std::string &name) const
+isl::pw_aff pw_aff::intersect_domain(const isl::basic_set &set) const
 {
-  auto res = isl_pw_multi_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return this->intersect_domain(isl::set(set));
 }
 
-isl::pw_multi_aff pw_multi_aff::fix_si(isl::dim type, unsigned int pos, int value) const
+isl::pw_aff pw_aff::intersect_domain(const isl::point &set) const
 {
-  auto res = isl_pw_multi_aff_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
-  return manage(res);
+  return this->intersect_domain(isl::set(set));
 }
 
-isl::pw_multi_aff pw_multi_aff::flat_range_product(isl::pw_multi_aff pma2) const
+isl::union_pw_aff pw_aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
 {
-  auto res = isl_pw_multi_aff_flat_range_product(copy(), pma2.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).intersect_domain_wrapped_domain(uset);
 }
 
-stat pw_multi_aff::foreach_piece(const std::function<stat(set, multi_aff)> &fn) const
+isl::union_pw_aff pw_aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
 {
-  struct fn_data {
-    const std::function<stat(set, 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)(manage(arg_0), manage(arg_1));
-    return ret.release();
-  };
-  auto res = isl_pw_multi_aff_foreach_piece(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return isl::union_pw_aff(*this).intersect_domain_wrapped_range(uset);
 }
 
-isl::pw_multi_aff pw_multi_aff::from_domain(isl::set set)
+isl::pw_aff pw_aff::intersect_params(isl::set set) const
 {
-  auto res = isl_pw_multi_aff_from_domain(set.release());
+  auto res = isl_pw_aff_intersect_params(copy(), set.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::from_map(isl::map map)
+boolean pw_aff::involves_locals() const
 {
-  auto res = isl_pw_multi_aff_from_map(map.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).involves_locals();
 }
 
-isl::pw_multi_aff pw_multi_aff::from_multi_pw_aff(isl::multi_pw_aff mpa)
+boolean pw_aff::involves_nan() const
 {
-  auto res = isl_pw_multi_aff_from_multi_pw_aff(mpa.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).involves_nan();
 }
 
-isl::pw_multi_aff pw_multi_aff::from_set(isl::set set)
+boolean pw_aff::involves_param(const isl::id &id) const
 {
-  auto res = isl_pw_multi_aff_from_set(set.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).involves_param(id);
 }
 
-isl::id pw_multi_aff::get_dim_id(isl::dim type, unsigned int pos) const
+boolean pw_aff::involves_param(const std::string &id) const
 {
-  auto res = isl_pw_multi_aff_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return this->involves_param(isl::id(ctx(), id));
 }
 
-std::string pw_multi_aff::get_dim_name(isl::dim type, unsigned int pos) const
+boolean pw_aff::involves_param(const isl::id_list &list) const
 {
-  auto res = isl_pw_multi_aff_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
+  return isl::pw_multi_aff(*this).involves_param(list);
 }
 
-isl::space pw_multi_aff::get_domain_space() const
+boolean pw_aff::is_cst() const
 {
-  auto res = isl_pw_multi_aff_get_domain_space(get());
+  auto res = isl_pw_aff_is_cst(get());
   return manage(res);
 }
 
-isl::pw_aff pw_multi_aff::get_pw_aff(int pos) const
+boolean pw_aff::is_equal(const isl::pw_aff &pa2) const
 {
-  auto res = isl_pw_multi_aff_get_pw_aff(get(), pos);
+  auto res = isl_pw_aff_is_equal(get(), pa2.get());
   return manage(res);
 }
 
-isl::space pw_multi_aff::get_space() const
+boolean pw_aff::isa_aff() const
 {
-  auto res = isl_pw_multi_aff_get_space(get());
+  auto res = isl_pw_aff_isa_aff(get());
   return manage(res);
 }
 
-isl::id pw_multi_aff::get_tuple_id(isl::dim type) const
+boolean pw_aff::isa_multi_aff() const
 {
-  auto res = isl_pw_multi_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::pw_multi_aff(*this).isa_multi_aff();
 }
 
-std::string pw_multi_aff::get_tuple_name(isl::dim type) const
+boolean pw_aff::isa_pw_multi_aff() const
 {
-  auto res = isl_pw_multi_aff_get_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  std::string tmp(res);
-  return tmp;
+  return isl::union_pw_aff(*this).isa_pw_multi_aff();
 }
 
-isl::pw_multi_aff pw_multi_aff::gist(isl::set set) const
+isl::set pw_aff::le_set(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_gist(copy(), set.release());
+  auto res = isl_pw_aff_le_set(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::gist_params(isl::set set) const
+isl::pw_aff_list pw_aff::list() const
 {
-  auto res = isl_pw_multi_aff_gist_params(copy(), set.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).list();
 }
 
-boolean pw_multi_aff::has_tuple_id(isl::dim type) const
+isl::set pw_aff::lt_set(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_pw_aff_lt_set(copy(), pwaff2.release());
   return manage(res);
 }
 
-boolean pw_multi_aff::has_tuple_name(isl::dim type) const
+isl::multi_pw_aff pw_aff::max(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::pw_multi_aff(*this).max(multi2);
 }
 
-isl::pw_multi_aff pw_multi_aff::identity(isl::space space)
+isl::pw_aff pw_aff::max(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_identity(space.release());
+  auto res = isl_pw_aff_max(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::identity_on_domain(isl::space space)
+isl::pw_aff pw_aff::max(const isl::aff &pwaff2) const
 {
-  auto res = isl_pw_multi_aff_identity_on_domain_space(space.release());
-  return manage(res);
+  return this->max(isl::pw_aff(pwaff2));
 }
 
-isl::pw_multi_aff pw_multi_aff::insert_domain(isl::space domain) const
+isl::multi_val pw_aff::max_multi_val() const
 {
-  auto res = isl_pw_multi_aff_insert_domain(copy(), domain.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).max_multi_val();
 }
 
-isl::pw_multi_aff pw_multi_aff::intersect_domain(isl::set set) const
+isl::multi_pw_aff pw_aff::min(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_intersect_domain(copy(), set.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).min(multi2);
 }
 
-isl::pw_multi_aff pw_multi_aff::intersect_domain_wrapped_domain(isl::set set) const
+isl::pw_aff pw_aff::min(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_intersect_domain_wrapped_domain(copy(), set.release());
+  auto res = isl_pw_aff_min(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::intersect_domain_wrapped_range(isl::set set) const
+isl::pw_aff pw_aff::min(const isl::aff &pwaff2) const
 {
-  auto res = isl_pw_multi_aff_intersect_domain_wrapped_range(copy(), set.release());
-  return manage(res);
+  return this->min(isl::pw_aff(pwaff2));
 }
 
-isl::pw_multi_aff pw_multi_aff::intersect_params(isl::set set) const
+isl::multi_val pw_aff::min_multi_val() const
 {
-  auto res = isl_pw_multi_aff_intersect_params(copy(), set.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).min_multi_val();
 }
 
-boolean pw_multi_aff::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::pw_aff pw_aff::mod(isl::val mod) const
 {
-  auto res = isl_pw_multi_aff_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_pw_aff_mod_val(copy(), mod.release());
   return manage(res);
 }
 
-boolean pw_multi_aff::involves_locals() const
+isl::pw_aff pw_aff::mod(long mod) const
 {
-  auto res = isl_pw_multi_aff_involves_locals(get());
-  return manage(res);
+  return this->mod(isl::val(ctx(), mod));
 }
 
-boolean pw_multi_aff::involves_nan() const
+isl::pw_aff pw_aff::mul(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_involves_nan(get());
+  auto res = isl_pw_aff_mul(copy(), pwaff2.release());
   return manage(res);
 }
 
-boolean pw_multi_aff::involves_param_id(const isl::id &id) const
+class size pw_aff::n_piece() const
 {
-  auto res = isl_pw_multi_aff_involves_param_id(get(), id.get());
-  return manage(res);
+  return isl::pw_multi_aff(*this).n_piece();
 }
 
-boolean pw_multi_aff::is_equal(const isl::pw_multi_aff &pma2) const
+isl::set pw_aff::ne_set(isl::pw_aff pwaff2) const
 {
-  auto res = isl_pw_multi_aff_is_equal(get(), pma2.get());
+  auto res = isl_pw_aff_ne_set(copy(), pwaff2.release());
   return manage(res);
 }
 
-boolean pw_multi_aff::isa_multi_aff() const
+isl::pw_aff pw_aff::neg() const
 {
-  auto res = isl_pw_multi_aff_isa_multi_aff(get());
+  auto res = isl_pw_aff_neg(copy());
   return manage(res);
 }
 
-isl::multi_val pw_multi_aff::max_multi_val() const
+isl::pw_aff pw_aff::param_on_domain(isl::set domain, isl::id id)
 {
-  auto res = isl_pw_multi_aff_max_multi_val(copy());
+  auto res = isl_pw_aff_param_on_domain_id(domain.release(), id.release());
   return manage(res);
 }
 
-isl::multi_val pw_multi_aff::min_multi_val() const
+boolean pw_aff::plain_is_empty() const
 {
-  auto res = isl_pw_multi_aff_min_multi_val(copy());
-  return manage(res);
+  return isl::union_pw_aff(*this).plain_is_empty();
 }
 
-isl::pw_multi_aff pw_multi_aff::multi_val_on_domain(isl::set domain, isl::multi_val mv)
+boolean pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_multi_val_on_domain(domain.release(), mv.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).plain_is_equal(multi2);
 }
 
-isl_size pw_multi_aff::n_piece() const
+boolean pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_n_piece(get());
-  return res;
+  return isl::union_pw_aff(*this).plain_is_equal(multi2);
 }
 
-isl::pw_multi_aff pw_multi_aff::neg() const
+isl::pw_multi_aff pw_aff::preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_pw_multi_aff_neg(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).preimage_domain_wrapped_domain(pma2);
 }
 
-boolean pw_multi_aff::plain_is_equal(const isl::pw_multi_aff &pma2) const
+isl::union_pw_multi_aff pw_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_multi_aff_plain_is_equal(get(), pma2.get());
-  return manage(res);
+  return isl::union_pw_aff(*this).preimage_domain_wrapped_domain(upma2);
 }
 
-isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(isl::pw_multi_aff pma2) const
+isl::multi_pw_aff pw_aff::product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(copy(), pma2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).product(multi2);
 }
 
-isl::pw_multi_aff pw_multi_aff::product(isl::pw_multi_aff pma2) const
+isl::pw_multi_aff pw_aff::product(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_pw_multi_aff_product(copy(), pma2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).product(pma2);
 }
 
-isl::pw_multi_aff pw_multi_aff::project_domain_on_params() const
+isl::pw_aff pw_aff::pullback(isl::multi_aff ma) const
 {
-  auto res = isl_pw_multi_aff_project_domain_on_params(copy());
+  auto res = isl_pw_aff_pullback_multi_aff(copy(), ma.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::project_out_map(isl::space space, isl::dim type, unsigned int first, unsigned int n)
+isl::pw_aff pw_aff::pullback(isl::multi_pw_aff mpa) const
 {
-  auto res = isl_pw_multi_aff_project_out_map(space.release(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_pw_aff_pullback_multi_pw_aff(copy(), mpa.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::pullback(isl::multi_aff ma) const
+isl::pw_aff pw_aff::pullback(isl::pw_multi_aff pma) const
 {
-  auto res = isl_pw_multi_aff_pullback_multi_aff(copy(), ma.release());
+  auto res = isl_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::pullback(isl::pw_multi_aff pma2) const
+isl::union_pw_aff pw_aff::pullback(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_pw_multi_aff_pullback_pw_multi_aff(copy(), pma2.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).pullback(upma);
 }
 
-isl::pw_multi_aff pw_multi_aff::range_factor_domain() const
+isl::pw_multi_aff_list pw_aff::pw_multi_aff_list() const
 {
-  auto res = isl_pw_multi_aff_range_factor_domain(copy());
-  return manage(res);
+  return isl::union_pw_aff(*this).pw_multi_aff_list();
 }
 
-isl::pw_multi_aff pw_multi_aff::range_factor_range() const
+isl::pw_multi_aff pw_aff::range_factor_domain() const
 {
-  auto res = isl_pw_multi_aff_range_factor_range(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_factor_domain();
 }
 
-isl::pw_multi_aff pw_multi_aff::range_map(isl::space space)
+isl::pw_multi_aff pw_aff::range_factor_range() const
 {
-  auto res = isl_pw_multi_aff_range_map(space.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_factor_range();
 }
 
-isl::pw_multi_aff pw_multi_aff::range_product(isl::pw_multi_aff pma2) const
+isl::multi_pw_aff pw_aff::range_product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_range_product(copy(), pma2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_product(multi2);
 }
 
-isl::pw_multi_aff pw_multi_aff::reset_tuple_id(isl::dim type) const
+isl::multi_union_pw_aff pw_aff::range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_pw_multi_aff_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return isl::union_pw_aff(*this).range_product(multi2);
 }
 
-isl::pw_multi_aff pw_multi_aff::reset_user() const
+isl::pw_multi_aff pw_aff::range_product(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_pw_multi_aff_reset_user(copy());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_product(pma2);
 }
 
-isl::pw_multi_aff pw_multi_aff::scale(isl::val v) const
+isl::union_pw_multi_aff pw_aff::range_product(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_multi_aff_scale_val(copy(), v.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).range_product(upma2);
 }
 
-isl::pw_multi_aff pw_multi_aff::scale_down(isl::val v) const
+isl::id pw_aff::range_tuple_id() const
 {
-  auto res = isl_pw_multi_aff_scale_down_val(copy(), v.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).range_tuple_id();
 }
 
-isl::pw_multi_aff pw_multi_aff::scale_multi_val(isl::multi_val mv) const
+isl::multi_pw_aff pw_aff::reset_range_tuple_id() const
 {
-  auto res = isl_pw_multi_aff_scale_multi_val(copy(), mv.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).reset_range_tuple_id();
 }
 
-isl::pw_multi_aff pw_multi_aff::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::multi_pw_aff pw_aff::reset_tuple_id(isl::dim type) const
 {
-  auto res = isl_pw_multi_aff_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).reset_tuple_id(type);
 }
 
-isl::pw_multi_aff pw_multi_aff::set_pw_aff(unsigned int pos, isl::pw_aff pa) const
+isl::multi_pw_aff pw_aff::scale(const isl::multi_val &mv) const
 {
-  auto res = isl_pw_multi_aff_set_pw_aff(copy(), pos, pa.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).scale(mv);
 }
 
-isl::pw_multi_aff pw_multi_aff::set_tuple_id(isl::dim type, isl::id id) const
+isl::pw_aff pw_aff::scale(isl::val v) const
 {
-  auto res = isl_pw_multi_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
+  auto res = isl_pw_aff_scale_val(copy(), v.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::sub(isl::pw_multi_aff pma2) const
+isl::pw_aff pw_aff::scale(long v) const
 {
-  auto res = isl_pw_multi_aff_sub(copy(), pma2.release());
-  return manage(res);
+  return this->scale(isl::val(ctx(), v));
 }
 
-isl::pw_multi_aff pw_multi_aff::subtract_domain(isl::set set) const
+isl::multi_pw_aff pw_aff::scale_down(const isl::multi_val &mv) const
 {
-  auto res = isl_pw_multi_aff_subtract_domain(copy(), set.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).scale_down(mv);
 }
 
-isl::pw_multi_aff pw_multi_aff::union_add(isl::pw_multi_aff pma2) const
+isl::pw_aff pw_aff::scale_down(isl::val f) const
 {
-  auto res = isl_pw_multi_aff_union_add(copy(), pma2.release());
+  auto res = isl_pw_aff_scale_down_val(copy(), f.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff::union_lexmax(isl::pw_multi_aff pma2) const
+isl::pw_aff pw_aff::scale_down(long f) const
 {
-  auto res = isl_pw_multi_aff_union_lexmax(copy(), pma2.release());
-  return manage(res);
+  return this->scale_down(isl::val(ctx(), f));
 }
 
-isl::pw_multi_aff pw_multi_aff::union_lexmin(isl::pw_multi_aff pma2) const
+isl::multi_pw_aff pw_aff::set_at(int pos, const isl::pw_aff &el) const
 {
-  auto res = isl_pw_multi_aff_union_lexmin(copy(), pma2.release());
-  return manage(res);
+  return isl::pw_multi_aff(*this).set_at(pos, el);
 }
 
-isl::pw_multi_aff pw_multi_aff::zero(isl::space space)
+isl::multi_union_pw_aff pw_aff::set_at(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_pw_multi_aff_zero(space.release());
-  return manage(res);
+  return isl::union_pw_aff(*this).set_at(pos, el);
 }
 
-// implementations for isl::pw_multi_aff_list
-pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr) {
-  return pw_multi_aff_list(ptr);
+isl::multi_pw_aff pw_aff::set_pw_aff(int pos, const isl::pw_aff &el) const
+{
+  return isl::pw_multi_aff(*this).set_pw_aff(pos, el);
 }
-pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr) {
-  ptr = isl_pw_multi_aff_list_copy(ptr);
-  return pw_multi_aff_list(ptr);
+
+isl::pw_multi_aff pw_aff::set_pw_aff(unsigned int pos, const isl::pw_aff &pa) const
+{
+  return isl::pw_multi_aff(*this).set_pw_aff(pos, pa);
 }
 
-pw_multi_aff_list::pw_multi_aff_list()
-    : ptr(nullptr) {}
+isl::pw_multi_aff pw_aff::set_range_tuple(const isl::id &id) const
+{
+  return isl::pw_multi_aff(*this).set_range_tuple(id);
+}
 
-pw_multi_aff_list::pw_multi_aff_list(const pw_multi_aff_list &obj)
-    : ptr(nullptr)
+isl::pw_multi_aff pw_aff::set_range_tuple(const std::string &id) const
 {
-  ptr = obj.copy();
+  return this->set_range_tuple(isl::id(ctx(), id));
 }
 
+isl::pw_aff pw_aff::set_tuple_id(isl::dim type, isl::id id) const
+{
+  auto res = isl_pw_aff_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
+  return manage(res);
+}
 
-pw_multi_aff_list::pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr)
-    : ptr(ptr) {}
+isl::pw_aff pw_aff::set_tuple_id(isl::dim type, const std::string &id) const
+{
+  return this->set_tuple_id(type, isl::id(ctx(), id));
+}
 
+isl::multi_union_pw_aff pw_aff::set_union_pw_aff(int pos, const isl::union_pw_aff &el) const
+{
+  return isl::union_pw_aff(*this).set_union_pw_aff(pos, el);
+}
 
-pw_multi_aff_list &pw_multi_aff_list::operator=(pw_multi_aff_list obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+class size pw_aff::size() const
+{
+  return isl::multi_pw_aff(*this).size();
 }
 
-pw_multi_aff_list::~pw_multi_aff_list() {
-  if (ptr)
-    isl_pw_multi_aff_list_free(ptr);
+isl::space pw_aff::space() const
+{
+  auto res = isl_pw_aff_get_space(get());
+  return manage(res);
 }
 
-__isl_give isl_pw_multi_aff_list *pw_multi_aff_list::copy() const & {
-  return isl_pw_multi_aff_list_copy(ptr);
+isl::space pw_aff::get_space() const
+{
+  return space();
 }
 
-__isl_keep isl_pw_multi_aff_list *pw_multi_aff_list::get() const {
-  return ptr;
+isl::multi_pw_aff pw_aff::sub(const isl::multi_pw_aff &multi2) const
+{
+  return isl::pw_multi_aff(*this).sub(multi2);
 }
 
-__isl_give isl_pw_multi_aff_list *pw_multi_aff_list::release() {
-  isl_pw_multi_aff_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::multi_union_pw_aff pw_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::union_pw_aff(*this).sub(multi2);
 }
 
-bool pw_multi_aff_list::is_null() const {
-  return ptr == nullptr;
+isl::pw_aff pw_aff::sub(isl::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_sub(copy(), pwaff2.release());
+  return manage(res);
 }
 
+isl::pw_multi_aff pw_aff::sub(const isl::pw_multi_aff &pma2) const
+{
+  return isl::pw_multi_aff(*this).sub(pma2);
+}
 
-isl::ctx pw_multi_aff_list::ctx() const {
-  return isl::ctx(isl_pw_multi_aff_list_get_ctx(ptr));
+isl::union_pw_aff pw_aff::sub(const isl::union_pw_aff &upa2) const
+{
+  return isl::union_pw_aff(*this).sub(upa2);
 }
 
-void pw_multi_aff_list::dump() const {
-  isl_pw_multi_aff_list_dump(get());
+isl::union_pw_multi_aff pw_aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_aff(*this).sub(upma2);
 }
 
+isl::pw_aff pw_aff::sub(const isl::aff &pwaff2) const
+{
+  return this->sub(isl::pw_aff(pwaff2));
+}
 
-isl::pw_multi_aff_list pw_multi_aff_list::add(isl::pw_multi_aff el) const
+isl::pw_aff pw_aff::subtract_domain(isl::set set) const
 {
-  auto res = isl_pw_multi_aff_list_add(copy(), el.release());
+  auto res = isl_pw_aff_subtract_domain(copy(), set.release());
   return manage(res);
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::alloc(isl::ctx ctx, int n)
+isl::union_pw_aff pw_aff::subtract_domain(const isl::space &space) const
 {
-  auto res = isl_pw_multi_aff_list_alloc(ctx.release(), n);
-  return manage(res);
+  return isl::union_pw_aff(*this).subtract_domain(space);
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::clear() const
+isl::union_pw_aff pw_aff::subtract_domain(const isl::union_set &uset) const
 {
-  auto res = isl_pw_multi_aff_list_clear(copy());
-  return manage(res);
+  return isl::union_pw_aff(*this).subtract_domain(uset);
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::concat(isl::pw_multi_aff_list list2) const
+isl::pw_aff pw_aff::subtract_domain(const isl::basic_set &set) const
 {
-  auto res = isl_pw_multi_aff_list_concat(copy(), list2.release());
-  return manage(res);
+  return this->subtract_domain(isl::set(set));
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::drop(unsigned int first, unsigned int n) const
+isl::pw_aff pw_aff::subtract_domain(const isl::point &set) const
 {
-  auto res = isl_pw_multi_aff_list_drop(copy(), first, n);
-  return manage(res);
+  return this->subtract_domain(isl::set(set));
 }
 
-stat pw_multi_aff_list::foreach(const std::function<stat(pw_multi_aff)> &fn) const
+isl::pw_aff pw_aff::tdiv_q(isl::pw_aff pa2) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_pw_multi_aff_list_foreach(get(), fn_lambda, &fn_data);
+  auto res = isl_pw_aff_tdiv_q(copy(), pa2.release());
   return manage(res);
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::from_pw_multi_aff(isl::pw_multi_aff el)
+isl::pw_aff pw_aff::tdiv_r(isl::pw_aff pa2) const
 {
-  auto res = isl_pw_multi_aff_list_from_pw_multi_aff(el.release());
+  auto res = isl_pw_aff_tdiv_r(copy(), pa2.release());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff_list::get_at(int index) const
+isl::pw_aff_list pw_aff::to_list() const
 {
-  auto res = isl_pw_multi_aff_list_get_at(get(), index);
+  auto res = isl_pw_aff_to_list(copy());
   return manage(res);
 }
 
-isl::pw_multi_aff pw_multi_aff_list::get_pw_multi_aff(int index) const
+isl::multi_pw_aff pw_aff::to_multi_pw_aff() const
 {
-  auto res = isl_pw_multi_aff_list_get_pw_multi_aff(get(), index);
-  return manage(res);
+  return isl::pw_multi_aff(*this).to_multi_pw_aff();
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::insert(unsigned int pos, isl::pw_multi_aff el) const
+isl::union_pw_aff pw_aff::to_union_pw_aff() const
 {
-  auto res = isl_pw_multi_aff_list_insert(copy(), pos, el.release());
+  auto res = isl_pw_aff_to_union_pw_aff(copy());
   return manage(res);
 }
 
-isl_size pw_multi_aff_list::n_pw_multi_aff() const
+isl::union_pw_multi_aff pw_aff::to_union_pw_multi_aff() const
 {
-  auto res = isl_pw_multi_aff_list_n_pw_multi_aff(get());
-  return res;
+  return isl::pw_multi_aff(*this).to_union_pw_multi_aff();
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::reverse() const
+isl::id pw_aff::tuple_id(isl::dim type) const
 {
-  auto res = isl_pw_multi_aff_list_reverse(copy());
+  auto res = isl_pw_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::set_pw_multi_aff(int index, isl::pw_multi_aff el) const
+isl::id pw_aff::get_tuple_id(isl::dim type) const
+{
+  return tuple_id(type);
+}
+
+isl::multi_pw_aff pw_aff::unbind_params_insert_domain(const isl::multi_id &domain) const
+{
+  return isl::pw_multi_aff(*this).unbind_params_insert_domain(domain);
+}
+
+isl::multi_pw_aff pw_aff::union_add(const isl::multi_pw_aff &mpa2) const
 {
-  auto res = isl_pw_multi_aff_list_set_pw_multi_aff(copy(), index, el.release());
+  return isl::pw_multi_aff(*this).union_add(mpa2);
+}
+
+isl::multi_union_pw_aff pw_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  return isl::union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::pw_aff pw_aff::union_add(isl::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_union_add(copy(), pwaff2.release());
   return manage(res);
 }
 
-isl_size pw_multi_aff_list::size() const
+isl::pw_multi_aff pw_aff::union_add(const isl::pw_multi_aff &pma2) const
 {
-  auto res = isl_pw_multi_aff_list_size(get());
-  return res;
+  return isl::pw_multi_aff(*this).union_add(pma2);
+}
+
+isl::union_pw_aff pw_aff::union_add(const isl::union_pw_aff &upa2) const
+{
+  return isl::union_pw_aff(*this).union_add(upa2);
+}
+
+isl::union_pw_multi_aff pw_aff::union_add(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_aff(*this).union_add(upma2);
 }
 
-isl::pw_multi_aff_list pw_multi_aff_list::swap(unsigned int pos1, unsigned int pos2) const
+isl::pw_aff pw_aff::union_add(const isl::aff &pwaff2) const
 {
-  auto res = isl_pw_multi_aff_list_swap(copy(), pos1, pos2);
+  return this->union_add(isl::pw_aff(pwaff2));
+}
+
+isl::pw_aff pw_aff::var_on_domain(isl::local_space ls, isl::dim type, unsigned int pos)
+{
+  auto res = isl_pw_aff_var_on_domain(ls.release(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-// implementations for isl::pw_qpolynomial
-pw_qpolynomial manage(__isl_take isl_pw_qpolynomial *ptr) {
-  return pw_qpolynomial(ptr);
+inline std::ostream &operator<<(std::ostream &os, const pw_aff &obj)
+{
+  char *str = isl_pw_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
-pw_qpolynomial manage_copy(__isl_keep isl_pw_qpolynomial *ptr) {
-  ptr = isl_pw_qpolynomial_copy(ptr);
-  return pw_qpolynomial(ptr);
+
+// implementations for isl::pw_aff_list
+pw_aff_list manage(__isl_take isl_pw_aff_list *ptr) {
+  return pw_aff_list(ptr);
+}
+pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr) {
+  ptr = isl_pw_aff_list_copy(ptr);
+  return pw_aff_list(ptr);
 }
 
-pw_qpolynomial::pw_qpolynomial()
+pw_aff_list::pw_aff_list()
     : ptr(nullptr) {}
 
-pw_qpolynomial::pw_qpolynomial(const pw_qpolynomial &obj)
+pw_aff_list::pw_aff_list(const pw_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
-pw_qpolynomial::pw_qpolynomial(__isl_take isl_pw_qpolynomial *ptr)
+pw_aff_list::pw_aff_list(__isl_take isl_pw_aff_list *ptr)
     : ptr(ptr) {}
 
-pw_qpolynomial::pw_qpolynomial(isl::ctx ctx, const std::string &str)
+pw_aff_list::pw_aff_list(isl::ctx ctx, int n)
 {
-  auto res = isl_pw_qpolynomial_read_from_str(ctx.release(), str.c_str());
+  auto res = isl_pw_aff_list_alloc(ctx.release(), n);
   ptr = res;
 }
 
-pw_qpolynomial &pw_qpolynomial::operator=(pw_qpolynomial obj) {
+pw_aff_list::pw_aff_list(isl::pw_aff el)
+{
+  auto res = isl_pw_aff_list_from_pw_aff(el.release());
+  ptr = res;
+}
+
+pw_aff_list::pw_aff_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_pw_aff_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+pw_aff_list &pw_aff_list::operator=(pw_aff_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
-pw_qpolynomial::~pw_qpolynomial() {
+pw_aff_list::~pw_aff_list() {
   if (ptr)
-    isl_pw_qpolynomial_free(ptr);
+    isl_pw_aff_list_free(ptr);
 }
 
-__isl_give isl_pw_qpolynomial *pw_qpolynomial::copy() const & {
-  return isl_pw_qpolynomial_copy(ptr);
+__isl_give isl_pw_aff_list *pw_aff_list::copy() const & {
+  return isl_pw_aff_list_copy(ptr);
 }
 
-__isl_keep isl_pw_qpolynomial *pw_qpolynomial::get() const {
+__isl_keep isl_pw_aff_list *pw_aff_list::get() const {
   return ptr;
 }
 
-__isl_give isl_pw_qpolynomial *pw_qpolynomial::release() {
-  isl_pw_qpolynomial *tmp = ptr;
+__isl_give isl_pw_aff_list *pw_aff_list::release() {
+  isl_pw_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
-bool pw_qpolynomial::is_null() const {
+bool pw_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
-
-isl::ctx pw_qpolynomial::ctx() const {
-  return isl::ctx(isl_pw_qpolynomial_get_ctx(ptr));
+isl::ctx pw_aff_list::ctx() const {
+  return isl::ctx(isl_pw_aff_list_get_ctx(ptr));
 }
 
-void pw_qpolynomial::dump() const {
-  isl_pw_qpolynomial_dump(get());
+isl::pw_aff_list pw_aff_list::add(isl::pw_aff el) const
+{
+  auto res = isl_pw_aff_list_add(copy(), el.release());
+  return manage(res);
 }
 
-
-isl::pw_qpolynomial pw_qpolynomial::add(isl::pw_qpolynomial pwqp2) const
+isl::pw_aff pw_aff_list::at(int index) const
 {
-  auto res = isl_pw_qpolynomial_add(copy(), pwqp2.release());
+  auto res = isl_pw_aff_list_get_at(get(), index);
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::add_dims(isl::dim type, unsigned int n) const
+isl::pw_aff pw_aff_list::get_at(int index) const
 {
-  auto res = isl_pw_qpolynomial_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return at(index);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::alloc(isl::set set, isl::qpolynomial qp)
+isl::pw_aff_list pw_aff_list::clear() const
 {
-  auto res = isl_pw_qpolynomial_alloc(set.release(), qp.release());
+  auto res = isl_pw_aff_list_clear(copy());
   return manage(res);
 }
 
-isl::qpolynomial pw_qpolynomial::as_qpolynomial() const
+isl::pw_aff_list pw_aff_list::concat(isl::pw_aff_list list2) const
 {
-  auto res = isl_pw_qpolynomial_as_qpolynomial(copy());
+  auto res = isl_pw_aff_list_concat(copy(), list2.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::coalesce() const
+isl::pw_aff_list pw_aff_list::drop(unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_qpolynomial_coalesce(copy());
+  auto res = isl_pw_aff_list_drop(copy(), first, n);
   return manage(res);
 }
 
-isl_size pw_qpolynomial::dim(isl::dim type) const
+stat pw_aff_list::foreach(const std::function<stat(isl::pw_aff)> &fn) const
 {
-  auto res = isl_pw_qpolynomial_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  struct fn_data {
+    std::function<stat(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);
+    auto ret = (data->func)(manage(arg_0));
+    return ret.release();
+  };
+  auto res = isl_pw_aff_list_foreach(get(), fn_lambda, &fn_data);
+  return manage(res);
 }
 
-isl::set pw_qpolynomial::domain() const
+isl::pw_aff_list pw_aff_list::insert(unsigned int pos, isl::pw_aff el) const
 {
-  auto res = isl_pw_qpolynomial_domain(copy());
+  auto res = isl_pw_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+class size pw_aff_list::size() const
 {
-  auto res = isl_pw_qpolynomial_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_pw_aff_list_size(get());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::drop_unused_params() const
+inline std::ostream &operator<<(std::ostream &os, const pw_aff_list &obj)
 {
-  auto res = isl_pw_qpolynomial_drop_unused_params(copy());
-  return manage(res);
+  char *str = isl_pw_aff_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::pw_multi_aff
+pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr) {
+  return pw_multi_aff(ptr);
+}
+pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr) {
+  ptr = isl_pw_multi_aff_copy(ptr);
+  return pw_multi_aff(ptr);
 }
 
-isl::val pw_qpolynomial::eval(isl::point pnt) const
+pw_multi_aff::pw_multi_aff()
+    : ptr(nullptr) {}
+
+pw_multi_aff::pw_multi_aff(const pw_multi_aff &obj)
+    : ptr(nullptr)
 {
-  auto res = isl_pw_qpolynomial_eval(copy(), pnt.release());
-  return manage(res);
+  ptr = obj.copy();
 }
 
-int pw_qpolynomial::find_dim_by_name(isl::dim type, const std::string &name) const
+pw_multi_aff::pw_multi_aff(__isl_take isl_pw_multi_aff *ptr)
+    : ptr(ptr) {}
+
+pw_multi_aff::pw_multi_aff(isl::multi_aff ma)
 {
-  auto res = isl_pw_qpolynomial_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  auto res = isl_pw_multi_aff_from_multi_aff(ma.release());
+  ptr = res;
 }
 
-isl::pw_qpolynomial pw_qpolynomial::fix_val(isl::dim type, unsigned int n, isl::val v) const
+pw_multi_aff::pw_multi_aff(isl::pw_aff pa)
 {
-  auto res = isl_pw_qpolynomial_fix_val(copy(), static_cast<enum isl_dim_type>(type), n, v.release());
-  return manage(res);
+  auto res = isl_pw_multi_aff_from_pw_aff(pa.release());
+  ptr = res;
 }
 
-stat pw_qpolynomial::foreach_piece(const std::function<stat(set, qpolynomial)> &fn) const
+pw_multi_aff::pw_multi_aff(isl::ctx ctx, const std::string &str)
 {
-  struct fn_data {
-    const std::function<stat(set, 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)(manage(arg_0), manage(arg_1));
-    return ret.release();
-  };
-  auto res = isl_pw_qpolynomial_foreach_piece(get(), fn_lambda, &fn_data);
-  return manage(res);
+  auto res = isl_pw_multi_aff_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+pw_multi_aff &pw_multi_aff::operator=(pw_multi_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_multi_aff::~pw_multi_aff() {
+  if (ptr)
+    isl_pw_multi_aff_free(ptr);
+}
+
+__isl_give isl_pw_multi_aff *pw_multi_aff::copy() const & {
+  return isl_pw_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_pw_multi_aff *pw_multi_aff::get() const {
+  return ptr;
 }
 
-isl::pw_qpolynomial pw_qpolynomial::from_pw_aff(isl::pw_aff pwaff)
+__isl_give isl_pw_multi_aff *pw_multi_aff::release() {
+  isl_pw_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool pw_multi_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::ctx pw_multi_aff::ctx() const {
+  return isl::ctx(isl_pw_multi_aff_get_ctx(ptr));
+}
+
+isl::multi_pw_aff pw_multi_aff::add(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_qpolynomial_from_pw_aff(pwaff.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).add(multi2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::from_qpolynomial(isl::qpolynomial qp)
+isl::multi_union_pw_aff pw_multi_aff::add(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_pw_qpolynomial_from_qpolynomial(qp.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).add(multi2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::from_range() const
+isl::pw_multi_aff pw_multi_aff::add(isl::pw_multi_aff pma2) const
 {
-  auto res = isl_pw_qpolynomial_from_range(copy());
+  auto res = isl_pw_multi_aff_add(copy(), pma2.release());
   return manage(res);
 }
 
-isl::space pw_qpolynomial::get_domain_space() const
+isl::union_pw_multi_aff pw_multi_aff::add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_qpolynomial_get_domain_space(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).add(upma2);
 }
 
-isl::space pw_qpolynomial::get_space() const
+isl::pw_multi_aff pw_multi_aff::add(const isl::multi_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_get_space(get());
-  return manage(res);
+  return this->add(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial pw_qpolynomial::gist(isl::set context) const
+isl::pw_multi_aff pw_multi_aff::add(const isl::pw_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_gist(copy(), context.release());
-  return manage(res);
+  return this->add(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial pw_qpolynomial::gist_params(isl::set context) const
+isl::pw_multi_aff pw_multi_aff::add_constant(isl::multi_val mv) const
 {
-  auto res = isl_pw_qpolynomial_gist_params(copy(), context.release());
+  auto res = isl_pw_multi_aff_add_constant_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-boolean pw_qpolynomial::has_equal_space(const isl::pw_qpolynomial &pwqp2) const
+isl::pw_multi_aff pw_multi_aff::add_constant(isl::val v) const
 {
-  auto res = isl_pw_qpolynomial_has_equal_space(get(), pwqp2.get());
+  auto res = isl_pw_multi_aff_add_constant_val(copy(), v.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::pw_multi_aff pw_multi_aff::add_constant(long v) const
 {
-  auto res = isl_pw_qpolynomial_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->add_constant(isl::val(ctx(), v));
 }
 
-isl::pw_qpolynomial pw_qpolynomial::intersect_domain(isl::set set) const
+isl::union_pw_multi_aff pw_multi_aff::add_pw_multi_aff(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_pw_qpolynomial_intersect_domain(copy(), set.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).add_pw_multi_aff(pma);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::intersect_domain_wrapped_domain(isl::set set) const
+isl::union_pw_multi_aff pw_multi_aff::apply(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_qpolynomial_intersect_domain_wrapped_domain(copy(), set.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).apply(upma2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::intersect_domain_wrapped_range(isl::set set) const
+isl::map pw_multi_aff::as_map() const
 {
-  auto res = isl_pw_qpolynomial_intersect_domain_wrapped_range(copy(), set.release());
+  auto res = isl_pw_multi_aff_as_map(copy());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::intersect_params(isl::set set) const
+isl::multi_aff pw_multi_aff::as_multi_aff() const
 {
-  auto res = isl_pw_qpolynomial_intersect_params(copy(), set.release());
+  auto res = isl_pw_multi_aff_as_multi_aff(copy());
   return manage(res);
 }
 
-boolean pw_qpolynomial::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::multi_union_pw_aff pw_multi_aff::as_multi_union_pw_aff() const
 {
-  auto res = isl_pw_qpolynomial_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).as_multi_union_pw_aff();
 }
 
-boolean pw_qpolynomial::involves_nan() const
+isl::pw_multi_aff pw_multi_aff::as_pw_multi_aff() const
 {
-  auto res = isl_pw_qpolynomial_involves_nan(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).as_pw_multi_aff();
 }
 
-boolean pw_qpolynomial::involves_param_id(const isl::id &id) const
+isl::set pw_multi_aff::as_set() const
 {
-  auto res = isl_pw_qpolynomial_involves_param_id(get(), id.get());
+  auto res = isl_pw_multi_aff_as_set(copy());
   return manage(res);
 }
 
-boolean pw_qpolynomial::is_zero() const
+isl::union_map pw_multi_aff::as_union_map() const
 {
-  auto res = isl_pw_qpolynomial_is_zero(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).as_union_map();
 }
 
-boolean pw_qpolynomial::isa_qpolynomial() const
+isl::pw_aff pw_multi_aff::at(int pos) const
 {
-  auto res = isl_pw_qpolynomial_isa_qpolynomial(get());
+  auto res = isl_pw_multi_aff_get_at(get(), pos);
   return manage(res);
 }
 
-isl::val pw_qpolynomial::max() const
+isl::pw_aff pw_multi_aff::get_at(int pos) const
 {
-  auto res = isl_pw_qpolynomial_max(copy());
-  return manage(res);
+  return at(pos);
 }
 
-isl::val pw_qpolynomial::min() const
+isl::set pw_multi_aff::bind(const isl::multi_id &tuple) const
 {
-  auto res = isl_pw_qpolynomial_min(copy());
-  return manage(res);
+  return isl::multi_pw_aff(*this).bind(tuple);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::pw_multi_aff pw_multi_aff::bind_domain(isl::multi_id tuple) const
 {
-  auto res = isl_pw_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);
+  auto res = isl_pw_multi_aff_bind_domain(copy(), tuple.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::mul(isl::pw_qpolynomial pwqp2) const
+isl::pw_multi_aff pw_multi_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
 {
-  auto res = isl_pw_qpolynomial_mul(copy(), pwqp2.release());
+  auto res = isl_pw_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
   return manage(res);
 }
 
-isl_size pw_qpolynomial::n_piece() const
+isl::pw_multi_aff pw_multi_aff::coalesce() const
 {
-  auto res = isl_pw_qpolynomial_n_piece(get());
-  return res;
+  auto res = isl_pw_multi_aff_coalesce(copy());
+  return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::neg() const
+class size pw_multi_aff::dim(isl::dim type) const
 {
-  auto res = isl_pw_qpolynomial_neg(copy());
+  auto res = isl_pw_multi_aff_dim(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean pw_qpolynomial::plain_is_equal(const isl::pw_qpolynomial &pwqp2) const
+isl::set pw_multi_aff::domain() const
 {
-  auto res = isl_pw_qpolynomial_plain_is_equal(get(), pwqp2.get());
+  auto res = isl_pw_multi_aff_domain(copy());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::pow(unsigned int exponent) const
+isl::pw_multi_aff pw_multi_aff::domain_map(isl::space space)
 {
-  auto res = isl_pw_qpolynomial_pow(copy(), exponent);
+  auto res = isl_pw_multi_aff_domain_map(space.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::project_domain_on_params() const
+isl::pw_multi_aff pw_multi_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_pw_qpolynomial_project_domain_on_params(copy());
+  auto res = isl_pw_multi_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::reset_domain_space(isl::space space) const
+isl::pw_multi_aff pw_multi_aff::extract_pw_multi_aff(const isl::space &space) const
 {
-  auto res = isl_pw_qpolynomial_reset_domain_space(copy(), space.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).extract_pw_multi_aff(space);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::reset_user() const
+isl::multi_pw_aff pw_multi_aff::flat_range_product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_qpolynomial_reset_user(copy());
-  return manage(res);
+  return isl::multi_pw_aff(*this).flat_range_product(multi2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::scale_down_val(isl::val v) const
+isl::multi_union_pw_aff pw_multi_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_pw_qpolynomial_scale_down_val(copy(), v.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).flat_range_product(multi2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::scale_val(isl::val v) const
+isl::pw_multi_aff pw_multi_aff::flat_range_product(isl::pw_multi_aff pma2) const
 {
-  auto res = isl_pw_qpolynomial_scale_val(copy(), v.release());
+  auto res = isl_pw_multi_aff_flat_range_product(copy(), pma2.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::split_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_pw_multi_aff pw_multi_aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_qpolynomial_split_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).flat_range_product(upma2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::split_periods(int max_periods) const
+isl::pw_multi_aff pw_multi_aff::flat_range_product(const isl::multi_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_split_periods(copy(), max_periods);
-  return manage(res);
+  return this->flat_range_product(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial pw_qpolynomial::sub(isl::pw_qpolynomial pwqp2) const
+isl::pw_multi_aff pw_multi_aff::flat_range_product(const isl::pw_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_sub(copy(), pwqp2.release());
-  return manage(res);
+  return this->flat_range_product(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial pw_qpolynomial::subtract_domain(isl::set set) const
+stat pw_multi_aff::foreach_piece(const std::function<stat(isl::set, isl::multi_aff)> &fn) const
 {
-  auto res = isl_pw_qpolynomial_subtract_domain(copy(), set.release());
+  struct fn_data {
+    std::function<stat(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);
+    auto ret = (data->func)(manage(arg_0), manage(arg_1));
+    return ret.release();
+  };
+  auto res = isl_pw_multi_aff_foreach_piece(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::to_polynomial(int sign) const
+isl::pw_multi_aff pw_multi_aff::from_map(isl::map map)
 {
-  auto res = isl_pw_qpolynomial_to_polynomial(copy(), sign);
+  auto res = isl_pw_multi_aff_from_map(map.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial::zero(isl::space space)
+isl::pw_multi_aff pw_multi_aff::gist(isl::set set) const
 {
-  auto res = isl_pw_qpolynomial_zero(space.release());
+  auto res = isl_pw_multi_aff_gist(copy(), set.release());
   return manage(res);
 }
 
-// implementations for isl::pw_qpolynomial_fold_list
-pw_qpolynomial_fold_list manage(__isl_take isl_pw_qpolynomial_fold_list *ptr) {
-  return pw_qpolynomial_fold_list(ptr);
+isl::union_pw_multi_aff pw_multi_aff::gist(const isl::union_set &context) const
+{
+  return isl::union_pw_multi_aff(*this).gist(context);
 }
-pw_qpolynomial_fold_list manage_copy(__isl_keep isl_pw_qpolynomial_fold_list *ptr) {
-  ptr = isl_pw_qpolynomial_fold_list_copy(ptr);
-  return pw_qpolynomial_fold_list(ptr);
+
+isl::pw_multi_aff pw_multi_aff::gist(const isl::basic_set &set) const
+{
+  return this->gist(isl::set(set));
 }
 
-pw_qpolynomial_fold_list::pw_qpolynomial_fold_list()
-    : ptr(nullptr) {}
+isl::pw_multi_aff pw_multi_aff::gist(const isl::point &set) const
+{
+  return this->gist(isl::set(set));
+}
 
-pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj)
-    : ptr(nullptr)
+boolean pw_multi_aff::has_range_tuple_id() const
 {
-  ptr = obj.copy();
+  auto res = isl_pw_multi_aff_has_range_tuple_id(get());
+  return manage(res);
 }
 
+isl::multi_pw_aff pw_multi_aff::identity() const
+{
+  return isl::multi_pw_aff(*this).identity();
+}
 
-pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(__isl_take isl_pw_qpolynomial_fold_list *ptr)
-    : ptr(ptr) {}
+isl::pw_multi_aff pw_multi_aff::identity_on_domain(isl::space space)
+{
+  auto res = isl_pw_multi_aff_identity_on_domain_space(space.release());
+  return manage(res);
+}
 
+isl::pw_multi_aff pw_multi_aff::insert_domain(isl::space domain) const
+{
+  auto res = isl_pw_multi_aff_insert_domain(copy(), domain.release());
+  return manage(res);
+}
 
-pw_qpolynomial_fold_list &pw_qpolynomial_fold_list::operator=(pw_qpolynomial_fold_list obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+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);
 }
 
-pw_qpolynomial_fold_list::~pw_qpolynomial_fold_list() {
-  if (ptr)
-    isl_pw_qpolynomial_fold_list_free(ptr);
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain(const isl::space &space) const
+{
+  return isl::union_pw_multi_aff(*this).intersect_domain(space);
 }
 
-__isl_give isl_pw_qpolynomial_fold_list *pw_qpolynomial_fold_list::copy() const & {
-  return isl_pw_qpolynomial_fold_list_copy(ptr);
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain(const isl::union_set &uset) const
+{
+  return isl::union_pw_multi_aff(*this).intersect_domain(uset);
 }
 
-__isl_keep isl_pw_qpolynomial_fold_list *pw_qpolynomial_fold_list::get() const {
-  return ptr;
+isl::pw_multi_aff pw_multi_aff::intersect_domain(const isl::basic_set &set) const
+{
+  return this->intersect_domain(isl::set(set));
 }
 
-__isl_give isl_pw_qpolynomial_fold_list *pw_qpolynomial_fold_list::release() {
-  isl_pw_qpolynomial_fold_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::pw_multi_aff pw_multi_aff::intersect_domain(const isl::point &set) const
+{
+  return this->intersect_domain(isl::set(set));
 }
 
-bool pw_qpolynomial_fold_list::is_null() const {
-  return ptr == nullptr;
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
+{
+  return isl::union_pw_multi_aff(*this).intersect_domain_wrapped_domain(uset);
 }
 
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
+{
+  return isl::union_pw_multi_aff(*this).intersect_domain_wrapped_range(uset);
+}
 
-isl::ctx pw_qpolynomial_fold_list::ctx() const {
-  return isl::ctx(isl_pw_qpolynomial_fold_list_get_ctx(ptr));
+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);
 }
 
-void pw_qpolynomial_fold_list::dump() const {
-  isl_pw_qpolynomial_fold_list_dump(get());
+boolean pw_multi_aff::involves_locals() const
+{
+  auto res = isl_pw_multi_aff_involves_locals(get());
+  return manage(res);
 }
 
+boolean pw_multi_aff::involves_nan() const
+{
+  return isl::multi_pw_aff(*this).involves_nan();
+}
 
+boolean pw_multi_aff::involves_param(const isl::id &id) const
+{
+  return isl::multi_pw_aff(*this).involves_param(id);
+}
 
-// implementations for isl::pw_qpolynomial_list
-pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr) {
-  return pw_qpolynomial_list(ptr);
+boolean pw_multi_aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::id(ctx(), id));
 }
-pw_qpolynomial_list manage_copy(__isl_keep isl_pw_qpolynomial_list *ptr) {
-  ptr = isl_pw_qpolynomial_list_copy(ptr);
-  return pw_qpolynomial_list(ptr);
+
+boolean pw_multi_aff::involves_param(const isl::id_list &list) const
+{
+  return isl::multi_pw_aff(*this).involves_param(list);
 }
 
-pw_qpolynomial_list::pw_qpolynomial_list()
-    : ptr(nullptr) {}
+boolean pw_multi_aff::isa_multi_aff() const
+{
+  auto res = isl_pw_multi_aff_isa_multi_aff(get());
+  return manage(res);
+}
 
-pw_qpolynomial_list::pw_qpolynomial_list(const pw_qpolynomial_list &obj)
-    : ptr(nullptr)
+boolean pw_multi_aff::isa_pw_multi_aff() const
 {
-  ptr = obj.copy();
+  return isl::union_pw_multi_aff(*this).isa_pw_multi_aff();
 }
 
+isl::pw_aff_list pw_multi_aff::list() const
+{
+  return isl::multi_pw_aff(*this).list();
+}
 
-pw_qpolynomial_list::pw_qpolynomial_list(__isl_take isl_pw_qpolynomial_list *ptr)
-    : ptr(ptr) {}
+isl::multi_pw_aff pw_multi_aff::max(const isl::multi_pw_aff &multi2) const
+{
+  return isl::multi_pw_aff(*this).max(multi2);
+}
 
+isl::multi_val pw_multi_aff::max_multi_val() const
+{
+  auto res = isl_pw_multi_aff_max_multi_val(copy());
+  return manage(res);
+}
 
-pw_qpolynomial_list &pw_qpolynomial_list::operator=(pw_qpolynomial_list obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+isl::multi_pw_aff pw_multi_aff::min(const isl::multi_pw_aff &multi2) const
+{
+  return isl::multi_pw_aff(*this).min(multi2);
 }
 
-pw_qpolynomial_list::~pw_qpolynomial_list() {
-  if (ptr)
-    isl_pw_qpolynomial_list_free(ptr);
+isl::multi_val pw_multi_aff::min_multi_val() const
+{
+  auto res = isl_pw_multi_aff_min_multi_val(copy());
+  return manage(res);
 }
 
-__isl_give isl_pw_qpolynomial_list *pw_qpolynomial_list::copy() const & {
-  return isl_pw_qpolynomial_list_copy(ptr);
+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);
 }
 
-__isl_keep isl_pw_qpolynomial_list *pw_qpolynomial_list::get() const {
-  return ptr;
+class size pw_multi_aff::n_piece() const
+{
+  auto res = isl_pw_multi_aff_n_piece(get());
+  return manage(res);
 }
 
-__isl_give isl_pw_qpolynomial_list *pw_qpolynomial_list::release() {
-  isl_pw_qpolynomial_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::multi_pw_aff pw_multi_aff::neg() const
+{
+  return isl::multi_pw_aff(*this).neg();
 }
 
-bool pw_qpolynomial_list::is_null() const {
-  return ptr == nullptr;
+boolean pw_multi_aff::plain_is_empty() const
+{
+  return isl::union_pw_multi_aff(*this).plain_is_empty();
 }
 
+boolean pw_multi_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+{
+  return isl::multi_pw_aff(*this).plain_is_equal(multi2);
+}
 
-isl::ctx pw_qpolynomial_list::ctx() const {
-  return isl::ctx(isl_pw_qpolynomial_list_get_ctx(ptr));
+boolean pw_multi_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::multi_pw_aff(*this).plain_is_equal(multi2);
 }
 
-void pw_qpolynomial_list::dump() const {
-  isl_pw_qpolynomial_list_dump(get());
+isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(isl::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(copy(), pma2.release());
+  return manage(res);
 }
 
+isl::union_pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::add(isl::pw_qpolynomial el) const
+isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::multi_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_list_add(copy(), el.release());
-  return manage(res);
+  return this->preimage_domain_wrapped_domain(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::alloc(isl::ctx ctx, int n)
+isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::pw_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_list_alloc(ctx.release(), n);
-  return manage(res);
+  return this->preimage_domain_wrapped_domain(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::clear() const
+isl::multi_pw_aff pw_multi_aff::product(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_pw_qpolynomial_list_clear(copy());
-  return manage(res);
+  return isl::multi_pw_aff(*this).product(multi2);
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::concat(isl::pw_qpolynomial_list list2) const
+isl::pw_multi_aff pw_multi_aff::product(isl::pw_multi_aff pma2) const
 {
-  auto res = isl_pw_qpolynomial_list_concat(copy(), list2.release());
+  auto res = isl_pw_multi_aff_product(copy(), pma2.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::drop(unsigned int first, unsigned int n) const
+isl::pw_multi_aff pw_multi_aff::product(const isl::multi_aff &pma2) const
 {
-  auto res = isl_pw_qpolynomial_list_drop(copy(), first, n);
-  return manage(res);
+  return this->product(isl::pw_multi_aff(pma2));
 }
 
-stat pw_qpolynomial_list::foreach(const std::function<stat(pw_qpolynomial)> &fn) const
+isl::pw_multi_aff pw_multi_aff::product(const isl::pw_aff &pma2) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_pw_qpolynomial_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return this->product(isl::pw_multi_aff(pma2));
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::from_pw_qpolynomial(isl::pw_qpolynomial el)
+isl::pw_multi_aff pw_multi_aff::project_out_map(isl::space space, isl::dim type, unsigned int first, unsigned int n)
 {
-  auto res = isl_pw_qpolynomial_list_from_pw_qpolynomial(el.release());
+  auto res = isl_pw_multi_aff_project_out_map(space.release(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::pw_qpolynomial pw_qpolynomial_list::get_at(int index) const
+isl::multi_pw_aff pw_multi_aff::pullback(const isl::multi_pw_aff &mpa2) const
 {
-  auto res = isl_pw_qpolynomial_list_get_at(get(), index);
-  return manage(res);
+  return isl::multi_pw_aff(*this).pullback(mpa2);
 }
 
-isl::pw_qpolynomial pw_qpolynomial_list::get_pw_qpolynomial(int index) const
+isl::pw_multi_aff pw_multi_aff::pullback(isl::multi_aff ma) const
 {
-  auto res = isl_pw_qpolynomial_list_get_pw_qpolynomial(get(), index);
+  auto res = isl_pw_multi_aff_pullback_multi_aff(copy(), ma.release());
   return manage(res);
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::insert(unsigned int pos, isl::pw_qpolynomial el) const
+isl::pw_multi_aff pw_multi_aff::pullback(isl::pw_multi_aff pma2) const
 {
-  auto res = isl_pw_qpolynomial_list_insert(copy(), pos, el.release());
+  auto res = isl_pw_multi_aff_pullback_pw_multi_aff(copy(), pma2.release());
   return manage(res);
 }
 
-isl_size pw_qpolynomial_list::n_pw_qpolynomial() const
+isl::union_pw_multi_aff pw_multi_aff::pullback(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_pw_qpolynomial_list_n_pw_qpolynomial(get());
-  return res;
+  return isl::union_pw_multi_aff(*this).pullback(upma2);
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::reverse() const
+isl::pw_multi_aff_list pw_multi_aff::pw_multi_aff_list() const
 {
-  auto res = isl_pw_qpolynomial_list_reverse(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).pw_multi_aff_list();
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::set_pw_qpolynomial(int index, isl::pw_qpolynomial el) const
+isl::pw_multi_aff pw_multi_aff::range_factor_domain() const
 {
-  auto res = isl_pw_qpolynomial_list_set_pw_qpolynomial(copy(), index, el.release());
+  auto res = isl_pw_multi_aff_range_factor_domain(copy());
   return manage(res);
 }
 
-isl_size pw_qpolynomial_list::size() const
+isl::pw_multi_aff pw_multi_aff::range_factor_range() const
 {
-  auto res = isl_pw_qpolynomial_list_size(get());
-  return res;
+  auto res = isl_pw_multi_aff_range_factor_range(copy());
+  return manage(res);
 }
 
-isl::pw_qpolynomial_list pw_qpolynomial_list::swap(unsigned int pos1, unsigned int pos2) const
+isl::pw_multi_aff pw_multi_aff::range_map(isl::space space)
 {
-  auto res = isl_pw_qpolynomial_list_swap(copy(), pos1, pos2);
+  auto res = isl_pw_multi_aff_range_map(space.release());
   return manage(res);
 }
 
-// implementations for isl::qpolynomial
-qpolynomial manage(__isl_take isl_qpolynomial *ptr) {
-  return qpolynomial(ptr);
-}
-qpolynomial manage_copy(__isl_keep isl_qpolynomial *ptr) {
-  ptr = isl_qpolynomial_copy(ptr);
-  return qpolynomial(ptr);
+isl::multi_pw_aff pw_multi_aff::range_product(const isl::multi_pw_aff &multi2) const
+{
+  return isl::multi_pw_aff(*this).range_product(multi2);
 }
 
-qpolynomial::qpolynomial()
-    : ptr(nullptr) {}
-
-qpolynomial::qpolynomial(const qpolynomial &obj)
-    : ptr(nullptr)
+isl::multi_union_pw_aff pw_multi_aff::range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  ptr = obj.copy();
+  return isl::multi_pw_aff(*this).range_product(multi2);
 }
 
-
-qpolynomial::qpolynomial(__isl_take isl_qpolynomial *ptr)
-    : ptr(ptr) {}
-
-
-qpolynomial &qpolynomial::operator=(qpolynomial obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
+isl::pw_multi_aff pw_multi_aff::range_product(isl::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_range_product(copy(), pma2.release());
+  return manage(res);
 }
 
-qpolynomial::~qpolynomial() {
-  if (ptr)
-    isl_qpolynomial_free(ptr);
+isl::union_pw_multi_aff pw_multi_aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_multi_aff(*this).range_product(upma2);
 }
 
-__isl_give isl_qpolynomial *qpolynomial::copy() const & {
-  return isl_qpolynomial_copy(ptr);
+isl::pw_multi_aff pw_multi_aff::range_product(const isl::multi_aff &pma2) const
+{
+  return this->range_product(isl::pw_multi_aff(pma2));
 }
 
-__isl_keep isl_qpolynomial *qpolynomial::get() const {
-  return ptr;
+isl::pw_multi_aff pw_multi_aff::range_product(const isl::pw_aff &pma2) const
+{
+  return this->range_product(isl::pw_multi_aff(pma2));
 }
 
-__isl_give isl_qpolynomial *qpolynomial::release() {
-  isl_qpolynomial *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+isl::id pw_multi_aff::range_tuple_id() const
+{
+  auto res = isl_pw_multi_aff_get_range_tuple_id(get());
+  return manage(res);
 }
 
-bool qpolynomial::is_null() const {
-  return ptr == nullptr;
+isl::id pw_multi_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
 }
 
-
-isl::ctx qpolynomial::ctx() const {
-  return isl::ctx(isl_qpolynomial_get_ctx(ptr));
+isl::multi_pw_aff pw_multi_aff::reset_range_tuple_id() const
+{
+  return isl::multi_pw_aff(*this).reset_range_tuple_id();
 }
 
-void qpolynomial::dump() const {
-  isl_qpolynomial_dump(get());
+isl::multi_pw_aff pw_multi_aff::reset_tuple_id(isl::dim type) const
+{
+  return isl::multi_pw_aff(*this).reset_tuple_id(type);
 }
 
+isl::multi_pw_aff pw_multi_aff::scale(const isl::multi_val &mv) const
+{
+  return isl::multi_pw_aff(*this).scale(mv);
+}
 
-isl::qpolynomial qpolynomial::add(isl::qpolynomial qp2) const
+isl::pw_multi_aff pw_multi_aff::scale(isl::val v) const
 {
-  auto res = isl_qpolynomial_add(copy(), qp2.release());
+  auto res = isl_pw_multi_aff_scale_val(copy(), v.release());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::add_dims(isl::dim type, unsigned int n) const
+isl::pw_multi_aff pw_multi_aff::scale(long v) const
 {
-  auto res = isl_qpolynomial_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
-  return manage(res);
+  return this->scale(isl::val(ctx(), v));
 }
 
-isl::qpolynomial qpolynomial::align_params(isl::space model) const
+isl::multi_pw_aff pw_multi_aff::scale_down(const isl::multi_val &mv) const
 {
-  auto res = isl_qpolynomial_align_params(copy(), model.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).scale_down(mv);
 }
 
-stat qpolynomial::as_polynomial_on_domain(const isl::basic_set &bset, const std::function<stat(basic_set, qpolynomial)> &fn) const
+isl::pw_multi_aff pw_multi_aff::scale_down(isl::val v) const
 {
-  struct fn_data {
-    const std::function<stat(basic_set, 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)(manage(arg_0), manage(arg_1));
-    return ret.release();
-  };
-  auto res = isl_qpolynomial_as_polynomial_on_domain(get(), bset.get(), fn_lambda, &fn_data);
+  auto res = isl_pw_multi_aff_scale_down_val(copy(), v.release());
   return manage(res);
 }
 
-isl_size qpolynomial::dim(isl::dim type) const
+isl::pw_multi_aff pw_multi_aff::scale_down(long v) const
 {
-  auto res = isl_qpolynomial_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return this->scale_down(isl::val(ctx(), v));
 }
 
-isl::qpolynomial qpolynomial::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::multi_pw_aff pw_multi_aff::set_at(int pos, const isl::pw_aff &el) const
 {
-  auto res = isl_qpolynomial_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::multi_pw_aff(*this).set_at(pos, el);
 }
 
-isl::val qpolynomial::eval(isl::point pnt) const
+isl::multi_union_pw_aff pw_multi_aff::set_at(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_qpolynomial_eval(copy(), pnt.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).set_at(pos, el);
 }
 
-stat qpolynomial::foreach_term(const std::function<stat(term)> &fn) const
+isl::multi_pw_aff pw_multi_aff::set_pw_aff(int pos, const isl::pw_aff &el) const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_qpolynomial_foreach_term(get(), fn_lambda, &fn_data);
-  return manage(res);
+  return isl::multi_pw_aff(*this).set_pw_aff(pos, el);
 }
 
-isl::qpolynomial qpolynomial::from_aff(isl::aff aff)
+isl::pw_multi_aff pw_multi_aff::set_pw_aff(unsigned int pos, isl::pw_aff pa) const
 {
-  auto res = isl_qpolynomial_from_aff(aff.release());
+  auto res = isl_pw_multi_aff_set_pw_aff(copy(), pos, pa.release());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::from_constraint(isl::constraint c, isl::dim type, unsigned int pos)
+isl::pw_multi_aff pw_multi_aff::set_range_tuple(isl::id id) const
 {
-  auto res = isl_qpolynomial_from_constraint(c.release(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_pw_multi_aff_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::from_term(isl::term term)
+isl::pw_multi_aff pw_multi_aff::set_range_tuple(const std::string &id) const
 {
-  auto res = isl_qpolynomial_from_term(term.release());
-  return manage(res);
+  return this->set_range_tuple(isl::id(ctx(), id));
 }
 
-isl::val qpolynomial::get_constant_val() const
+isl::multi_union_pw_aff pw_multi_aff::set_union_pw_aff(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_qpolynomial_get_constant_val(get());
-  return manage(res);
+  return isl::multi_pw_aff(*this).set_union_pw_aff(pos, el);
 }
 
-isl::space qpolynomial::get_domain_space() const
+class size pw_multi_aff::size() const
 {
-  auto res = isl_qpolynomial_get_domain_space(get());
-  return manage(res);
+  return isl::multi_pw_aff(*this).size();
 }
 
-isl::space qpolynomial::get_space() const
+isl::space pw_multi_aff::space() const
 {
-  auto res = isl_qpolynomial_get_space(get());
+  auto res = isl_pw_multi_aff_get_space(get());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::gist(isl::set context) const
+isl::space pw_multi_aff::get_space() const
 {
-  auto res = isl_qpolynomial_gist(copy(), context.release());
-  return manage(res);
+  return space();
 }
 
-isl::qpolynomial qpolynomial::gist_params(isl::set context) const
+isl::multi_pw_aff pw_multi_aff::sub(const isl::multi_pw_aff &multi2) const
 {
-  auto res = isl_qpolynomial_gist_params(copy(), context.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).sub(multi2);
 }
 
-isl::qpolynomial qpolynomial::homogenize() const
+isl::multi_union_pw_aff pw_multi_aff::sub(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_qpolynomial_homogenize(copy());
-  return manage(res);
+  return isl::multi_pw_aff(*this).sub(multi2);
 }
 
-isl::qpolynomial qpolynomial::infty_on_domain(isl::space domain)
+isl::pw_multi_aff pw_multi_aff::sub(isl::pw_multi_aff pma2) const
 {
-  auto res = isl_qpolynomial_infty_on_domain(domain.release());
+  auto res = isl_pw_multi_aff_sub(copy(), pma2.release());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::insert_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_pw_multi_aff pw_multi_aff::sub(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_qpolynomial_insert_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).sub(upma2);
 }
 
-boolean qpolynomial::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::pw_multi_aff pw_multi_aff::sub(const isl::multi_aff &pma2) const
 {
-  auto res = isl_qpolynomial_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return this->sub(isl::pw_multi_aff(pma2));
 }
 
-boolean qpolynomial::is_infty() const
+isl::pw_multi_aff pw_multi_aff::sub(const isl::pw_aff &pma2) const
 {
-  auto res = isl_qpolynomial_is_infty(get());
-  return manage(res);
+  return this->sub(isl::pw_multi_aff(pma2));
 }
 
-boolean qpolynomial::is_nan() const
+isl::pw_multi_aff pw_multi_aff::subtract_domain(isl::set set) const
 {
-  auto res = isl_qpolynomial_is_nan(get());
+  auto res = isl_pw_multi_aff_subtract_domain(copy(), set.release());
   return manage(res);
 }
 
-boolean qpolynomial::is_neginfty() const
+isl::union_pw_multi_aff pw_multi_aff::subtract_domain(const isl::space &space) const
 {
-  auto res = isl_qpolynomial_is_neginfty(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).subtract_domain(space);
 }
 
-boolean qpolynomial::is_zero() const
+isl::union_pw_multi_aff pw_multi_aff::subtract_domain(const isl::union_set &uset) const
 {
-  auto res = isl_qpolynomial_is_zero(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).subtract_domain(uset);
 }
 
-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
+isl::pw_multi_aff pw_multi_aff::subtract_domain(const isl::basic_set &set) 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);
+  return this->subtract_domain(isl::set(set));
 }
 
-isl::qpolynomial qpolynomial::mul(isl::qpolynomial qp2) const
+isl::pw_multi_aff pw_multi_aff::subtract_domain(const isl::point &set) const
 {
-  auto res = isl_qpolynomial_mul(copy(), qp2.release());
-  return manage(res);
+  return this->subtract_domain(isl::set(set));
 }
 
-isl::qpolynomial qpolynomial::nan_on_domain(isl::space domain)
+isl::pw_multi_aff_list pw_multi_aff::to_list() const
 {
-  auto res = isl_qpolynomial_nan_on_domain(domain.release());
+  auto res = isl_pw_multi_aff_to_list(copy());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::neg() const
+isl::multi_pw_aff pw_multi_aff::to_multi_pw_aff() const
 {
-  auto res = isl_qpolynomial_neg(copy());
+  auto res = isl_pw_multi_aff_to_multi_pw_aff(copy());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::neginfty_on_domain(isl::space domain)
+isl::union_pw_multi_aff pw_multi_aff::to_union_pw_multi_aff() const
 {
-  auto res = isl_qpolynomial_neginfty_on_domain(domain.release());
+  auto res = isl_pw_multi_aff_to_union_pw_multi_aff(copy());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::one_on_domain(isl::space domain)
+isl::id pw_multi_aff::tuple_id(isl::dim type) const
 {
-  auto res = isl_qpolynomial_one_on_domain(domain.release());
+  auto res = isl_pw_multi_aff_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean qpolynomial::plain_is_equal(const isl::qpolynomial &qp2) const
+isl::id pw_multi_aff::get_tuple_id(isl::dim type) const
 {
-  auto res = isl_qpolynomial_plain_is_equal(get(), qp2.get());
-  return manage(res);
+  return tuple_id(type);
 }
 
-isl::qpolynomial qpolynomial::pow(unsigned int power) const
+isl::multi_pw_aff pw_multi_aff::unbind_params_insert_domain(const isl::multi_id &domain) const
 {
-  auto res = isl_qpolynomial_pow(copy(), power);
-  return manage(res);
+  return isl::multi_pw_aff(*this).unbind_params_insert_domain(domain);
 }
 
-isl::qpolynomial qpolynomial::project_domain_on_params() const
+isl::multi_pw_aff pw_multi_aff::union_add(const isl::multi_pw_aff &mpa2) const
 {
-  auto res = isl_qpolynomial_project_domain_on_params(copy());
-  return manage(res);
+  return isl::multi_pw_aff(*this).union_add(mpa2);
 }
 
-isl::qpolynomial qpolynomial::scale_down_val(isl::val v) const
+isl::multi_union_pw_aff pw_multi_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
 {
-  auto res = isl_qpolynomial_scale_down_val(copy(), v.release());
-  return manage(res);
+  return isl::multi_pw_aff(*this).union_add(mupa2);
 }
 
-isl::qpolynomial qpolynomial::scale_val(isl::val v) const
+isl::pw_multi_aff pw_multi_aff::union_add(isl::pw_multi_aff pma2) const
 {
-  auto res = isl_qpolynomial_scale_val(copy(), v.release());
+  auto res = isl_pw_multi_aff_union_add(copy(), pma2.release());
   return manage(res);
 }
 
-int qpolynomial::sgn() const
+isl::union_pw_multi_aff pw_multi_aff::union_add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_qpolynomial_sgn(get());
-  return res;
+  return isl::union_pw_multi_aff(*this).union_add(upma2);
 }
 
-isl::qpolynomial qpolynomial::sub(isl::qpolynomial qp2) const
+isl::pw_multi_aff pw_multi_aff::union_add(const isl::multi_aff &pma2) const
 {
-  auto res = isl_qpolynomial_sub(copy(), qp2.release());
-  return manage(res);
+  return this->union_add(isl::pw_multi_aff(pma2));
 }
 
-isl::qpolynomial qpolynomial::val_on_domain(isl::space space, isl::val val)
+isl::pw_multi_aff pw_multi_aff::union_add(const isl::pw_aff &pma2) const
 {
-  auto res = isl_qpolynomial_val_on_domain(space.release(), val.release());
-  return manage(res);
+  return this->union_add(isl::pw_multi_aff(pma2));
 }
 
-isl::qpolynomial qpolynomial::var_on_domain(isl::space domain, isl::dim type, unsigned int pos)
+isl::pw_multi_aff pw_multi_aff::zero(isl::space space)
 {
-  auto res = isl_qpolynomial_var_on_domain(domain.release(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_pw_multi_aff_zero(space.release());
   return manage(res);
 }
 
-isl::qpolynomial qpolynomial::zero_on_domain(isl::space domain)
+inline std::ostream &operator<<(std::ostream &os, const pw_multi_aff &obj)
 {
-  auto res = isl_qpolynomial_zero_on_domain(domain.release());
-  return manage(res);
+  char *str = isl_pw_multi_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
-// implementations for isl::qpolynomial_list
-qpolynomial_list manage(__isl_take isl_qpolynomial_list *ptr) {
-  return qpolynomial_list(ptr);
+// implementations for isl::pw_multi_aff_list
+pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr) {
+  return pw_multi_aff_list(ptr);
 }
-qpolynomial_list manage_copy(__isl_keep isl_qpolynomial_list *ptr) {
-  ptr = isl_qpolynomial_list_copy(ptr);
-  return qpolynomial_list(ptr);
+pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr) {
+  ptr = isl_pw_multi_aff_list_copy(ptr);
+  return pw_multi_aff_list(ptr);
 }
 
-qpolynomial_list::qpolynomial_list()
+pw_multi_aff_list::pw_multi_aff_list()
     : ptr(nullptr) {}
 
-qpolynomial_list::qpolynomial_list(const qpolynomial_list &obj)
+pw_multi_aff_list::pw_multi_aff_list(const pw_multi_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
-qpolynomial_list::qpolynomial_list(__isl_take isl_qpolynomial_list *ptr)
+pw_multi_aff_list::pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr)
     : ptr(ptr) {}
 
+pw_multi_aff_list::pw_multi_aff_list(isl::ctx ctx, int n)
+{
+  auto res = isl_pw_multi_aff_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+pw_multi_aff_list::pw_multi_aff_list(isl::pw_multi_aff el)
+{
+  auto res = isl_pw_multi_aff_list_from_pw_multi_aff(el.release());
+  ptr = res;
+}
 
-qpolynomial_list &qpolynomial_list::operator=(qpolynomial_list obj) {
+pw_multi_aff_list::pw_multi_aff_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_pw_multi_aff_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+pw_multi_aff_list &pw_multi_aff_list::operator=(pw_multi_aff_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
-qpolynomial_list::~qpolynomial_list() {
+pw_multi_aff_list::~pw_multi_aff_list() {
   if (ptr)
-    isl_qpolynomial_list_free(ptr);
+    isl_pw_multi_aff_list_free(ptr);
 }
 
-__isl_give isl_qpolynomial_list *qpolynomial_list::copy() const & {
-  return isl_qpolynomial_list_copy(ptr);
+__isl_give isl_pw_multi_aff_list *pw_multi_aff_list::copy() const & {
+  return isl_pw_multi_aff_list_copy(ptr);
 }
 
-__isl_keep isl_qpolynomial_list *qpolynomial_list::get() const {
+__isl_keep isl_pw_multi_aff_list *pw_multi_aff_list::get() const {
   return ptr;
 }
 
-__isl_give isl_qpolynomial_list *qpolynomial_list::release() {
-  isl_qpolynomial_list *tmp = ptr;
+__isl_give isl_pw_multi_aff_list *pw_multi_aff_list::release() {
+  isl_pw_multi_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
-bool qpolynomial_list::is_null() const {
+bool pw_multi_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
-
-isl::ctx qpolynomial_list::ctx() const {
-  return isl::ctx(isl_qpolynomial_list_get_ctx(ptr));
+isl::ctx pw_multi_aff_list::ctx() const {
+  return isl::ctx(isl_pw_multi_aff_list_get_ctx(ptr));
 }
 
-void qpolynomial_list::dump() const {
-  isl_qpolynomial_list_dump(get());
+isl::pw_multi_aff_list pw_multi_aff_list::add(isl::pw_multi_aff el) const
+{
+  auto res = isl_pw_multi_aff_list_add(copy(), el.release());
+  return manage(res);
 }
 
-
-isl::qpolynomial_list qpolynomial_list::add(isl::qpolynomial el) const
+isl::pw_multi_aff pw_multi_aff_list::at(int index) const
 {
-  auto res = isl_qpolynomial_list_add(copy(), el.release());
+  auto res = isl_pw_multi_aff_list_get_at(get(), index);
   return manage(res);
 }
 
-isl::qpolynomial_list qpolynomial_list::alloc(isl::ctx ctx, int n)
+isl::pw_multi_aff pw_multi_aff_list::get_at(int index) const
 {
-  auto res = isl_qpolynomial_list_alloc(ctx.release(), n);
-  return manage(res);
+  return at(index);
 }
 
-isl::qpolynomial_list qpolynomial_list::clear() const
+isl::pw_multi_aff_list pw_multi_aff_list::clear() const
 {
-  auto res = isl_qpolynomial_list_clear(copy());
+  auto res = isl_pw_multi_aff_list_clear(copy());
   return manage(res);
 }
 
-isl::qpolynomial_list qpolynomial_list::concat(isl::qpolynomial_list list2) const
+isl::pw_multi_aff_list pw_multi_aff_list::concat(isl::pw_multi_aff_list list2) const
 {
-  auto res = isl_qpolynomial_list_concat(copy(), list2.release());
+  auto res = isl_pw_multi_aff_list_concat(copy(), list2.release());
   return manage(res);
 }
 
-isl::qpolynomial_list qpolynomial_list::drop(unsigned int first, unsigned int n) const
+isl::pw_multi_aff_list pw_multi_aff_list::drop(unsigned int first, unsigned int n) const
 {
-  auto res = isl_qpolynomial_list_drop(copy(), first, n);
+  auto res = isl_pw_multi_aff_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat qpolynomial_list::foreach(const std::function<stat(qpolynomial)> &fn) const
+stat pw_multi_aff_list::foreach(const std::function<stat(isl::pw_multi_aff)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(qpolynomial)> *func;
-  } fn_data = { &fn };
-  auto fn_lambda = [](isl_qpolynomial *arg_0, void *arg_1) -> isl_stat {
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
-  auto res = isl_qpolynomial_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
-}
-
-isl::qpolynomial_list qpolynomial_list::from_qpolynomial(isl::qpolynomial el)
-{
-  auto res = isl_qpolynomial_list_from_qpolynomial(el.release());
-  return manage(res);
-}
-
-isl::qpolynomial qpolynomial_list::get_at(int index) const
-{
-  auto res = isl_qpolynomial_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::qpolynomial qpolynomial_list::get_qpolynomial(int index) const
-{
-  auto res = isl_qpolynomial_list_get_qpolynomial(get(), index);
-  return manage(res);
-}
-
-isl::qpolynomial_list qpolynomial_list::insert(unsigned int pos, isl::qpolynomial el) const
-{
-  auto res = isl_qpolynomial_list_insert(copy(), pos, el.release());
+  auto res = isl_pw_multi_aff_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl_size qpolynomial_list::n_qpolynomial() const
-{
-  auto res = isl_qpolynomial_list_n_qpolynomial(get());
-  return res;
-}
-
-isl::qpolynomial_list qpolynomial_list::reverse() const
+isl::pw_multi_aff_list pw_multi_aff_list::insert(unsigned int pos, isl::pw_multi_aff el) const
 {
-  auto res = isl_qpolynomial_list_reverse(copy());
+  auto res = isl_pw_multi_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl::qpolynomial_list qpolynomial_list::set_qpolynomial(int index, isl::qpolynomial el) const
+class size pw_multi_aff_list::size() const
 {
-  auto res = isl_qpolynomial_list_set_qpolynomial(copy(), index, el.release());
+  auto res = isl_pw_multi_aff_list_size(get());
   return manage(res);
 }
 
-isl_size qpolynomial_list::size() const
+inline std::ostream &operator<<(std::ostream &os, const pw_multi_aff_list &obj)
 {
-  auto res = isl_qpolynomial_list_size(get());
-  return res;
-}
-
-isl::qpolynomial_list qpolynomial_list::swap(unsigned int pos1, unsigned int pos2) const
-{
-  auto res = isl_qpolynomial_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_pw_multi_aff_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::schedule
 schedule manage(__isl_take isl_schedule *ptr) {
   return schedule(ptr);
 }
 schedule manage_copy(__isl_keep isl_schedule *ptr) {
   ptr = isl_schedule_copy(ptr);
   return schedule(ptr);
 }
 
 schedule::schedule()
     : ptr(nullptr) {}
 
 schedule::schedule(const schedule &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 schedule::schedule(__isl_take isl_schedule *ptr)
     : ptr(ptr) {}
 
 schedule::schedule(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_schedule_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
__isl_give isl_schedule *schedule::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool schedule::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx schedule::ctx() const {
   return isl::ctx(isl_schedule_get_ctx(ptr));
 }
 
-void schedule::dump() const {
-  isl_schedule_dump(get());
-}
-
-
 isl::schedule schedule::align_params(isl::space space) const
 {
   auto res = isl_schedule_align_params(copy(), space.release());
   return manage(res);
 }
 
-isl::schedule schedule::empty(isl::space space)
+isl::union_set schedule::domain() const
 {
-  auto res = isl_schedule_empty(space.release());
-  return manage(res);
-}
-
-isl::schedule schedule::from_domain(isl::union_set domain)
-{
-  auto res = isl_schedule_from_domain(domain.release());
+  auto res = isl_schedule_get_domain(get());
   return manage(res);
 }
 
 isl::union_set schedule::get_domain() const
 {
-  auto res = isl_schedule_get_domain(get());
-  return manage(res);
+  return domain();
 }
 
-isl::union_map schedule::get_map() const
-{
-  auto res = isl_schedule_get_map(get());
-  return manage(res);
-}
-
-isl::schedule_node schedule::get_root() const
+isl::schedule schedule::from_domain(isl::union_set domain)
 {
-  auto res = isl_schedule_get_root(get());
+  auto res = isl_schedule_from_domain(domain.release());
   return manage(res);
 }
 
 isl::schedule schedule::gist_domain_params(isl::set context) const
 {
   auto res = isl_schedule_gist_domain_params(copy(), context.release());
   return manage(res);
 }
 
-isl::schedule schedule::insert_context(isl::set context) const
-{
-  auto res = isl_schedule_insert_context(copy(), context.release());
-  return manage(res);
-}
-
-isl::schedule schedule::insert_guard(isl::set guard) const
-{
-  auto res = isl_schedule_insert_guard(copy(), guard.release());
-  return manage(res);
-}
-
 isl::schedule schedule::insert_partial_schedule(isl::multi_union_pw_aff partial) const
 {
   auto res = isl_schedule_insert_partial_schedule(copy(), partial.release());
   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);
 }
 
-boolean schedule::plain_is_equal(const isl::schedule &schedule2) const
+isl::union_map schedule::map() const
 {
-  auto res = isl_schedule_plain_is_equal(get(), schedule2.get());
+  auto res = isl_schedule_get_map(get());
   return manage(res);
 }
 
+isl::union_map schedule::get_map() const
+{
+  return map();
+}
+
 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 schedule::reset_user() const
+isl::schedule_node schedule::root() const
 {
-  auto res = isl_schedule_reset_user(copy());
+  auto res = isl_schedule_get_root(get());
   return manage(res);
 }
 
+isl::schedule_node schedule::get_root() const
+{
+  return root();
+}
+
 isl::schedule schedule::sequence(isl::schedule schedule2) const
 {
   auto res = isl_schedule_sequence(copy(), schedule2.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const schedule &obj)
+{
+  char *str = isl_schedule_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::schedule_constraints
 schedule_constraints manage(__isl_take isl_schedule_constraints *ptr) {
   return schedule_constraints(ptr);
 }
 schedule_constraints manage_copy(__isl_keep isl_schedule_constraints *ptr) {
   ptr = isl_schedule_constraints_copy(ptr);
   return schedule_constraints(ptr);
 }
 
 schedule_constraints::schedule_constraints()
     : ptr(nullptr) {}
 
 schedule_constraints::schedule_constraints(const schedule_constraints &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 schedule_constraints::schedule_constraints(__isl_take isl_schedule_constraints *ptr)
     : ptr(ptr) {}
 
 schedule_constraints::schedule_constraints(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_schedule_constraints_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
__isl_give isl_schedule_constraints *schedule_constraints::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool schedule_constraints::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx schedule_constraints::ctx() const {
   return isl::ctx(isl_schedule_constraints_get_ctx(ptr));
 }
 
-void schedule_constraints::dump() const {
-  isl_schedule_constraints_dump(get());
+isl::union_map schedule_constraints::coincidence() const
+{
+  auto res = isl_schedule_constraints_get_coincidence(get());
+  return manage(res);
 }
 
-
-isl::schedule_constraints schedule_constraints::apply(isl::union_map umap) const
+isl::union_map schedule_constraints::get_coincidence() const
 {
-  auto res = isl_schedule_constraints_apply(copy(), umap.release());
-  return manage(res);
+  return coincidence();
 }
 
 isl::schedule schedule_constraints::compute_schedule() const
 {
   auto res = isl_schedule_constraints_compute_schedule(copy());
   return manage(res);
 }
 
-isl::union_map schedule_constraints::get_coincidence() const
+isl::union_map schedule_constraints::conditional_validity() const
 {
-  auto res = isl_schedule_constraints_get_coincidence(get());
+  auto res = isl_schedule_constraints_get_conditional_validity(get());
   return manage(res);
 }
 
 isl::union_map schedule_constraints::get_conditional_validity() const
 {
-  auto res = isl_schedule_constraints_get_conditional_validity(get());
-  return manage(res);
+  return conditional_validity();
 }
 
-isl::union_map schedule_constraints::get_conditional_validity_condition() const
+isl::union_map schedule_constraints::conditional_validity_condition() const
 {
   auto res = isl_schedule_constraints_get_conditional_validity_condition(get());
   return manage(res);
 }
 
-isl::set schedule_constraints::get_context() const
+isl::union_map schedule_constraints::get_conditional_validity_condition() const
+{
+  return conditional_validity_condition();
+}
+
+isl::set schedule_constraints::context() const
 {
   auto res = isl_schedule_constraints_get_context(get());
   return manage(res);
 }
 
-isl::union_set schedule_constraints::get_domain() const
+isl::set schedule_constraints::get_context() const
 {
-  auto res = isl_schedule_constraints_get_domain(get());
-  return manage(res);
+  return context();
 }
 
-isl::union_map schedule_constraints::get_proximity() const
+isl::union_set schedule_constraints::domain() const
 {
-  auto res = isl_schedule_constraints_get_proximity(get());
+  auto res = isl_schedule_constraints_get_domain(get());
   return manage(res);
 }
 
-isl::union_map schedule_constraints::get_validity() const
+isl::union_set schedule_constraints::get_domain() const
 {
-  auto res = isl_schedule_constraints_get_validity(get());
-  return manage(res);
+  return domain();
 }
 
 isl::schedule_constraints schedule_constraints::on_domain(isl::union_set domain)
 {
   auto res = isl_schedule_constraints_on_domain(domain.release());
   return manage(res);
 }
 
+isl::union_map schedule_constraints::proximity() const
+{
+  auto res = isl_schedule_constraints_get_proximity(get());
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::get_proximity() const
+{
+  return proximity();
+}
+
 isl::schedule_constraints schedule_constraints::set_coincidence(isl::union_map coincidence) const
 {
   auto res = isl_schedule_constraints_set_coincidence(copy(), coincidence.release());
   return manage(res);
 }
 
 isl::schedule_constraints schedule_constraints::set_conditional_validity(isl::union_map condition, isl::union_map validity) const
 {

 }
 
 isl::schedule_constraints schedule_constraints::set_validity(isl::union_map validity) const
 {
   auto res = isl_schedule_constraints_set_validity(copy(), validity.release());
   return manage(res);
 }
 
+isl::union_map schedule_constraints::validity() const
+{
+  auto res = isl_schedule_constraints_get_validity(get());
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::get_validity() const
+{
+  return validity();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_constraints &obj)
+{
+  char *str = isl_schedule_constraints_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::schedule_node
 schedule_node manage(__isl_take isl_schedule_node *ptr) {
   return schedule_node(ptr);
 }
 schedule_node manage_copy(__isl_keep isl_schedule_node *ptr) {
   ptr = isl_schedule_node_copy(ptr);
   return schedule_node(ptr);
 }
 
 schedule_node::schedule_node()
     : ptr(nullptr) {}
 
 schedule_node::schedule_node(const schedule_node &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 schedule_node::schedule_node(__isl_take isl_schedule_node *ptr)
     : ptr(ptr) {}
 
-
 schedule_node &schedule_node::operator=(schedule_node obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 schedule_node::~schedule_node() {
   if (ptr)
     isl_schedule_node_free(ptr);
__isl_give isl_schedule_node *schedule_node::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool schedule_node::is_null() const {
   return ptr == nullptr;
 }
 
+template <typename T, typename>
+boolean schedule_node::isa_type(T subtype) const
+{
+  if (is_null())
+    return boolean();
+  return isl_schedule_node_get_type(get()) == subtype;
+}
+template <class T>
+boolean schedule_node::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T schedule_node::as() const
+{
+ if (isa<T>().is_false())
+    isl_die(ctx().get(), isl_error_invalid, "not an object of the requested subtype", return T());
+  return T(copy());
+}
 
 isl::ctx schedule_node::ctx() const {
   return isl::ctx(isl_schedule_node_get_ctx(ptr));
 }
 
-void schedule_node::dump() const {
-  isl_schedule_node_dump(get());
+isl::schedule_node schedule_node::ancestor(int generation) const
+{
+  auto res = isl_schedule_node_ancestor(copy(), generation);
+  return manage(res);
+}
+
+class size schedule_node::ancestor_child_position(const isl::schedule_node &ancestor) const
+{
+  auto res = isl_schedule_node_get_ancestor_child_position(get(), ancestor.get());
+  return manage(res);
 }
 
+class size schedule_node::get_ancestor_child_position(const isl::schedule_node &ancestor) const
+{
+  return ancestor_child_position(ancestor);
+}
 
-isl::schedule_node schedule_node::align_params(isl::space space) const
+isl::schedule_node schedule_node::child(int pos) const
 {
-  auto res = isl_schedule_node_align_params(copy(), space.release());
+  auto res = isl_schedule_node_child(copy(), pos);
   return manage(res);
 }
 
-isl::schedule_node schedule_node::ancestor(int generation) const
+class size schedule_node::child_position() const
 {
-  auto res = isl_schedule_node_ancestor(copy(), generation);
+  auto res = isl_schedule_node_get_child_position(get());
   return manage(res);
 }
 
-boolean schedule_node::band_member_get_coincident(int pos) const
+class size schedule_node::get_child_position() const
 {
-  auto res = isl_schedule_node_band_member_get_coincident(get(), pos);
+  return child_position();
+}
+
+isl::union_set schedule_node::domain() const
+{
+  auto res = isl_schedule_node_get_domain(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::band_member_set_coincident(int pos, int coincident) const
+isl::union_set schedule_node::get_domain() const
+{
+  return domain();
+}
+
+boolean schedule_node::every_descendant(const std::function<boolean(isl::schedule_node)> &test) const
 {
-  auto res = isl_schedule_node_band_member_set_coincident(copy(), pos, coincident);
+  struct test_data {
+    std::function<boolean(isl::schedule_node)> func;
+  } test_data = { test };
+  auto test_lambda = [](isl_schedule_node *arg_0, void *arg_1) -> isl_bool {
+    auto *data = static_cast<struct test_data *>(arg_1);
+    auto ret = (data->func)(manage_copy(arg_0));
+    return ret.release();
+  };
+  auto res = isl_schedule_node_every_descendant(get(), test_lambda, &test_data);
   return manage(res);
 }
 
-isl::schedule_node schedule_node::band_set_ast_build_options(isl::union_set options) const
+isl::schedule_node schedule_node::first_child() const
 {
-  auto res = isl_schedule_node_band_set_ast_build_options(copy(), options.release());
+  auto res = isl_schedule_node_first_child(copy());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::child(int pos) const
+stat schedule_node::foreach_ancestor_top_down(const std::function<stat(isl::schedule_node)> &fn) const
 {
-  auto res = isl_schedule_node_child(copy(), pos);
+  struct fn_data {
+    std::function<stat(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);
+    auto ret = (data->func)(manage_copy(arg_0));
+    return ret.release();
+  };
+  auto res = isl_schedule_node_foreach_ancestor_top_down(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::set schedule_node::context_get_context() const
+stat schedule_node::foreach_descendant_top_down(const std::function<boolean(isl::schedule_node)> &fn) const
 {
-  auto res = isl_schedule_node_context_get_context(get());
+  struct fn_data {
+    std::function<boolean(isl::schedule_node)> func;
+  } fn_data = { fn };
+  auto fn_lambda = [](isl_schedule_node *arg_0, void *arg_1) -> isl_bool {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    auto ret = (data->func)(manage_copy(arg_0));
+    return ret.release();
+  };
+  auto res = isl_schedule_node_foreach_descendant_top_down(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::schedule_node schedule_node::cut() const
+isl::schedule_node schedule_node::from_domain(isl::union_set domain)
 {
-  auto res = isl_schedule_node_cut(copy());
+  auto res = isl_schedule_node_from_domain(domain.release());
   return manage(res);
 }
 
-isl::union_set schedule_node::domain_get_domain() const
+isl::schedule_node schedule_node::from_extension(isl::union_map extension)
 {
-  auto res = isl_schedule_node_domain_get_domain(get());
+  auto res = isl_schedule_node_from_extension(extension.release());
   return manage(res);
 }
 
-isl::union_pw_multi_aff schedule_node::expansion_get_contraction() const
+isl::schedule_node schedule_node::graft_after(isl::schedule_node graft) const
 {
-  auto res = isl_schedule_node_expansion_get_contraction(get());
+  auto res = isl_schedule_node_graft_after(copy(), graft.release());
   return manage(res);
 }
 
-isl::union_map schedule_node::expansion_get_expansion() const
+isl::schedule_node schedule_node::graft_before(isl::schedule_node graft) const
 {
-  auto res = isl_schedule_node_expansion_get_expansion(get());
+  auto res = isl_schedule_node_graft_before(copy(), graft.release());
   return manage(res);
 }
 
-isl::union_map schedule_node::extension_get_extension() const
+boolean schedule_node::has_children() const
 {
-  auto res = isl_schedule_node_extension_get_extension(get());
+  auto res = isl_schedule_node_has_children(get());
   return manage(res);
 }
 
-isl::union_set schedule_node::filter_get_filter() const
+boolean schedule_node::has_next_sibling() const
 {
-  auto res = isl_schedule_node_filter_get_filter(get());
+  auto res = isl_schedule_node_has_next_sibling(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::first_child() const
+boolean schedule_node::has_parent() const
 {
-  auto res = isl_schedule_node_first_child(copy());
+  auto res = isl_schedule_node_has_parent(get());
   return manage(res);
 }
 
-stat schedule_node::foreach_ancestor_top_down(const std::function<stat(schedule_node)> &fn) const
+boolean schedule_node::has_previous_sibling() const
 {
-  struct fn_data {
-    const std::function<stat(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)(manage_copy(arg_0));
-    return ret.release();
-  };
-  auto res = isl_schedule_node_foreach_ancestor_top_down(get(), fn_lambda, &fn_data);
+  auto res = isl_schedule_node_has_previous_sibling(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::from_domain(isl::union_set domain)
+isl::schedule_node schedule_node::insert_context(isl::set context) const
 {
-  auto res = isl_schedule_node_from_domain(domain.release());
+  auto res = isl_schedule_node_insert_context(copy(), context.release());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::from_extension(isl::union_map extension)
+isl::schedule_node schedule_node::insert_filter(isl::union_set filter) const
 {
-  auto res = isl_schedule_node_from_extension(extension.release());
+  auto res = isl_schedule_node_insert_filter(copy(), filter.release());
   return manage(res);
 }
 
-isl_size schedule_node::get_ancestor_child_position(const isl::schedule_node &ancestor) const
+isl::schedule_node schedule_node::insert_guard(isl::set context) const
 {
-  auto res = isl_schedule_node_get_ancestor_child_position(get(), ancestor.get());
-  return res;
+  auto res = isl_schedule_node_insert_guard(copy(), context.release());
+  return manage(res);
 }
 
-isl::schedule_node schedule_node::get_child(int pos) const
+isl::schedule_node schedule_node::insert_mark(isl::id mark) const
 {
-  auto res = isl_schedule_node_get_child(get(), pos);
+  auto res = isl_schedule_node_insert_mark(copy(), mark.release());
   return manage(res);
 }
 
-isl_size schedule_node::get_child_position() const
+isl::schedule_node schedule_node::insert_mark(const std::string &mark) const
 {
-  auto res = isl_schedule_node_get_child_position(get());
-  return res;
+  return this->insert_mark(isl::id(ctx(), mark));
 }
 
-isl::union_set schedule_node::get_domain() const
+isl::schedule_node schedule_node::insert_partial_schedule(isl::multi_union_pw_aff schedule) const
 {
-  auto res = isl_schedule_node_get_domain(get());
+  auto res = isl_schedule_node_insert_partial_schedule(copy(), schedule.release());
   return manage(res);
 }
 
-isl::multi_union_pw_aff schedule_node::get_prefix_schedule_multi_union_pw_aff() const
+isl::schedule_node schedule_node::insert_sequence(isl::union_set_list filters) const
 {
-  auto res = isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(get());
+  auto res = isl_schedule_node_insert_sequence(copy(), filters.release());
   return manage(res);
 }
 
-isl::union_map schedule_node::get_prefix_schedule_relation() const
+isl::schedule_node schedule_node::insert_set(isl::union_set_list filters) const
 {
-  auto res = isl_schedule_node_get_prefix_schedule_relation(get());
+  auto res = isl_schedule_node_insert_set(copy(), filters.release());
   return manage(res);
 }
 
-isl::union_map schedule_node::get_prefix_schedule_union_map() const
+boolean schedule_node::is_equal(const isl::schedule_node &node2) const
 {
-  auto res = isl_schedule_node_get_prefix_schedule_union_map(get());
+  auto res = isl_schedule_node_is_equal(get(), node2.get());
   return manage(res);
 }
 
-isl::union_pw_multi_aff schedule_node::get_prefix_schedule_union_pw_multi_aff() const
+boolean schedule_node::is_subtree_anchored() const
 {
-  auto res = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(get());
+  auto res = isl_schedule_node_is_subtree_anchored(get());
   return manage(res);
 }
 
-isl::schedule schedule_node::get_schedule() const
+isl::schedule_node schedule_node::map_descendant_bottom_up(const std::function<isl::schedule_node(isl::schedule_node)> &fn) const
 {
-  auto res = isl_schedule_node_get_schedule(get());
+  struct fn_data {
+    std::function<isl::schedule_node(isl::schedule_node)> func;
+  } fn_data = { fn };
+  auto fn_lambda = [](isl_schedule_node *arg_0, void *arg_1) -> isl_schedule_node * {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    auto ret = (data->func)(manage(arg_0));
+    return ret.release();
+  };
+  auto res = isl_schedule_node_map_descendant_bottom_up(copy(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl_size schedule_node::get_schedule_depth() const
+class size schedule_node::n_children() const
 {
-  auto res = isl_schedule_node_get_schedule_depth(get());
-  return res;
+  auto res = isl_schedule_node_n_children(get());
+  return manage(res);
 }
 
-isl::schedule_node schedule_node::get_shared_ancestor(const isl::schedule_node &node2) const
+isl::schedule_node schedule_node::next_sibling() const
 {
-  auto res = isl_schedule_node_get_shared_ancestor(get(), node2.get());
+  auto res = isl_schedule_node_next_sibling(copy());
   return manage(res);
 }
 
-isl::union_pw_multi_aff schedule_node::get_subtree_contraction() const
+isl::schedule_node schedule_node::order_after(isl::union_set filter) const
 {
-  auto res = isl_schedule_node_get_subtree_contraction(get());
+  auto res = isl_schedule_node_order_after(copy(), filter.release());
   return manage(res);
 }
 
-isl::union_map schedule_node::get_subtree_expansion() const
+isl::schedule_node schedule_node::order_before(isl::union_set filter) const
 {
-  auto res = isl_schedule_node_get_subtree_expansion(get());
+  auto res = isl_schedule_node_order_before(copy(), filter.release());
   return manage(res);
 }
 
-isl::union_map schedule_node::get_subtree_schedule_union_map() const
+isl::schedule_node schedule_node::parent() const
 {
-  auto res = isl_schedule_node_get_subtree_schedule_union_map(get());
+  auto res = isl_schedule_node_parent(copy());
   return manage(res);
 }
 
-isl_size schedule_node::get_tree_depth() const
+isl::multi_union_pw_aff schedule_node::prefix_schedule_multi_union_pw_aff() const
 {
-  auto res = isl_schedule_node_get_tree_depth(get());
-  return res;
+  auto res = isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(get());
+  return manage(res);
 }
 
-isl::union_set schedule_node::get_universe_domain() const
+isl::multi_union_pw_aff schedule_node::get_prefix_schedule_multi_union_pw_aff() const
 {
-  auto res = isl_schedule_node_get_universe_domain(get());
-  return manage(res);
+  return prefix_schedule_multi_union_pw_aff();
 }
 
-isl::schedule_node schedule_node::graft_after(isl::schedule_node graft) const
+isl::union_map schedule_node::prefix_schedule_relation() const
 {
-  auto res = isl_schedule_node_graft_after(copy(), graft.release());
+  auto res = isl_schedule_node_get_prefix_schedule_relation(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::graft_before(isl::schedule_node graft) const
+isl::union_map schedule_node::get_prefix_schedule_relation() const
 {
-  auto res = isl_schedule_node_graft_before(copy(), graft.release());
-  return manage(res);
+  return prefix_schedule_relation();
 }
 
-isl::schedule_node schedule_node::group(isl::id group_id) const
+isl::union_map schedule_node::prefix_schedule_union_map() const
 {
-  auto res = isl_schedule_node_group(copy(), group_id.release());
+  auto res = isl_schedule_node_get_prefix_schedule_union_map(get());
   return manage(res);
 }
 
-isl::set schedule_node::guard_get_guard() const
+isl::union_map schedule_node::get_prefix_schedule_union_map() const
 {
-  auto res = isl_schedule_node_guard_get_guard(get());
-  return manage(res);
+  return prefix_schedule_union_map();
 }
 
-boolean schedule_node::has_children() const
+isl::union_pw_multi_aff schedule_node::prefix_schedule_union_pw_multi_aff() const
 {
-  auto res = isl_schedule_node_has_children(get());
+  auto res = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(get());
   return manage(res);
 }
 
-boolean schedule_node::has_next_sibling() const
+isl::union_pw_multi_aff schedule_node::get_prefix_schedule_union_pw_multi_aff() const
 {
-  auto res = isl_schedule_node_has_next_sibling(get());
+  return prefix_schedule_union_pw_multi_aff();
+}
+
+isl::schedule_node schedule_node::previous_sibling() const
+{
+  auto res = isl_schedule_node_previous_sibling(copy());
   return manage(res);
 }
 
-boolean schedule_node::has_parent() const
+isl::schedule_node schedule_node::root() const
 {
-  auto res = isl_schedule_node_has_parent(get());
+  auto res = isl_schedule_node_root(copy());
   return manage(res);
 }
 
-boolean schedule_node::has_previous_sibling() const
+isl::schedule schedule_node::schedule() const
 {
-  auto res = isl_schedule_node_has_previous_sibling(get());
+  auto res = isl_schedule_node_get_schedule(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_context(isl::set context) const
+isl::schedule schedule_node::get_schedule() const
 {
-  auto res = isl_schedule_node_insert_context(copy(), context.release());
+  return schedule();
+}
+
+class size schedule_node::schedule_depth() const
+{
+  auto res = isl_schedule_node_get_schedule_depth(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_filter(isl::union_set filter) const
+class size schedule_node::get_schedule_depth() const
 {
-  auto res = isl_schedule_node_insert_filter(copy(), filter.release());
+  return schedule_depth();
+}
+
+isl::schedule_node schedule_node::shared_ancestor(const isl::schedule_node &node2) const
+{
+  auto res = isl_schedule_node_get_shared_ancestor(get(), node2.get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_guard(isl::set context) const
+isl::schedule_node schedule_node::get_shared_ancestor(const isl::schedule_node &node2) const
 {
-  auto res = isl_schedule_node_insert_guard(copy(), context.release());
+  return shared_ancestor(node2);
+}
+
+class size schedule_node::tree_depth() const
+{
+  auto res = isl_schedule_node_get_tree_depth(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_mark(isl::id mark) const
+class size schedule_node::get_tree_depth() const
 {
-  auto res = isl_schedule_node_insert_mark(copy(), mark.release());
+  return tree_depth();
+}
+
+isl::union_set schedule_node::universe_domain() const
+{
+  auto res = isl_schedule_node_get_universe_domain(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_partial_schedule(isl::multi_union_pw_aff schedule) const
+isl::union_set schedule_node::get_universe_domain() const
 {
-  auto res = isl_schedule_node_insert_partial_schedule(copy(), schedule.release());
+  return universe_domain();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_band
+schedule_node_band::schedule_node_band()
+    : schedule_node() {}
+
+schedule_node_band::schedule_node_band(const schedule_node_band &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_band::schedule_node_band(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_band &schedule_node_band::operator=(schedule_node_band obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_band::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::union_set schedule_node_band::ast_build_options() const
+{
+  auto res = isl_schedule_node_band_get_ast_build_options(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_sequence(isl::union_set_list filters) const
+isl::union_set schedule_node_band::get_ast_build_options() const
 {
-  auto res = isl_schedule_node_insert_sequence(copy(), filters.release());
+  return ast_build_options();
+}
+
+isl::set schedule_node_band::ast_isolate_option() const
+{
+  auto res = isl_schedule_node_band_get_ast_isolate_option(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::insert_set(isl::union_set_list filters) const
+isl::set schedule_node_band::get_ast_isolate_option() const
 {
-  auto res = isl_schedule_node_insert_set(copy(), filters.release());
+  return ast_isolate_option();
+}
+
+boolean schedule_node_band::member_get_coincident(int pos) const
+{
+  auto res = isl_schedule_node_band_member_get_coincident(get(), pos);
   return manage(res);
 }
 
-boolean schedule_node::is_equal(const isl::schedule_node &node2) const
+schedule_node_band schedule_node_band::member_set_coincident(int pos, int coincident) const
 {
-  auto res = isl_schedule_node_is_equal(get(), node2.get());
+  auto res = isl_schedule_node_band_member_set_coincident(copy(), pos, coincident);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::mod(isl::multi_val mv) const
+{
+  auto res = isl_schedule_node_band_mod(copy(), mv.release());
+  return manage(res).as<schedule_node_band>();
+}
+
+class size schedule_node_band::n_member() const
+{
+  auto res = isl_schedule_node_band_n_member(get());
   return manage(res);
 }
 
-boolean schedule_node::is_subtree_anchored() const
+isl::multi_union_pw_aff schedule_node_band::partial_schedule() const
 {
-  auto res = isl_schedule_node_is_subtree_anchored(get());
+  auto res = isl_schedule_node_band_get_partial_schedule(get());
   return manage(res);
 }
 
-isl::id schedule_node::mark_get_id() const
+isl::multi_union_pw_aff schedule_node_band::get_partial_schedule() const
 {
-  auto res = isl_schedule_node_mark_get_id(get());
+  return partial_schedule();
+}
+
+boolean schedule_node_band::permutable() const
+{
+  auto res = isl_schedule_node_band_get_permutable(get());
   return manage(res);
 }
 
-isl_size schedule_node::n_children() const
+boolean schedule_node_band::get_permutable() const
 {
-  auto res = isl_schedule_node_n_children(get());
-  return res;
+  return permutable();
 }
 
-isl::schedule_node schedule_node::next_sibling() const
+schedule_node_band schedule_node_band::scale(isl::multi_val mv) const
 {
-  auto res = isl_schedule_node_next_sibling(copy());
+  auto res = isl_schedule_node_band_scale(copy(), mv.release());
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::scale_down(isl::multi_val mv) const
+{
+  auto res = isl_schedule_node_band_scale_down(copy(), mv.release());
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::set_ast_build_options(isl::union_set options) const
+{
+  auto res = isl_schedule_node_band_set_ast_build_options(copy(), options.release());
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::set_permutable(int permutable) const
+{
+  auto res = isl_schedule_node_band_set_permutable(copy(), permutable);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::shift(isl::multi_union_pw_aff shift) const
+{
+  auto res = isl_schedule_node_band_shift(copy(), shift.release());
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::split(int pos) const
+{
+  auto res = isl_schedule_node_band_split(copy(), pos);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::tile(isl::multi_val sizes) const
+{
+  auto res = isl_schedule_node_band_tile(copy(), sizes.release());
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_default(int pos) const
+{
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_default);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_atomic(int pos) const
+{
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_atomic);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_unroll(int pos) const
+{
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_unroll);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_separate(int pos) const
+{
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_separate);
+  return manage(res).as<schedule_node_band>();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_band &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_context
+schedule_node_context::schedule_node_context()
+    : schedule_node() {}
+
+schedule_node_context::schedule_node_context(const schedule_node_context &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_context::schedule_node_context(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_context &schedule_node_context::operator=(schedule_node_context obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_context::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::set schedule_node_context::context() const
+{
+  auto res = isl_schedule_node_context_get_context(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::order_after(isl::union_set filter) const
+isl::set schedule_node_context::get_context() const
 {
-  auto res = isl_schedule_node_order_after(copy(), filter.release());
+  return context();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_context &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_domain
+schedule_node_domain::schedule_node_domain()
+    : schedule_node() {}
+
+schedule_node_domain::schedule_node_domain(const schedule_node_domain &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_domain::schedule_node_domain(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_domain &schedule_node_domain::operator=(schedule_node_domain obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_domain::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::union_set schedule_node_domain::domain() const
+{
+  auto res = isl_schedule_node_domain_get_domain(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::order_before(isl::union_set filter) const
+isl::union_set schedule_node_domain::get_domain() const
 {
-  auto res = isl_schedule_node_order_before(copy(), filter.release());
+  return domain();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_domain &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_expansion
+schedule_node_expansion::schedule_node_expansion()
+    : schedule_node() {}
+
+schedule_node_expansion::schedule_node_expansion(const schedule_node_expansion &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_expansion::schedule_node_expansion(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_expansion &schedule_node_expansion::operator=(schedule_node_expansion obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_expansion::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::union_pw_multi_aff schedule_node_expansion::contraction() const
+{
+  auto res = isl_schedule_node_expansion_get_contraction(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::parent() const
+isl::union_pw_multi_aff schedule_node_expansion::get_contraction() const
 {
-  auto res = isl_schedule_node_parent(copy());
+  return contraction();
+}
+
+isl::union_map schedule_node_expansion::expansion() const
+{
+  auto res = isl_schedule_node_expansion_get_expansion(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::previous_sibling() const
+isl::union_map schedule_node_expansion::get_expansion() const
 {
-  auto res = isl_schedule_node_previous_sibling(copy());
+  return expansion();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_expansion &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_extension
+schedule_node_extension::schedule_node_extension()
+    : schedule_node() {}
+
+schedule_node_extension::schedule_node_extension(const schedule_node_extension &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_extension::schedule_node_extension(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_extension &schedule_node_extension::operator=(schedule_node_extension obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_extension::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::union_map schedule_node_extension::extension() const
+{
+  auto res = isl_schedule_node_extension_get_extension(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::reset_user() const
+isl::union_map schedule_node_extension::get_extension() const
+{
+  return extension();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_extension &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_filter
+schedule_node_filter::schedule_node_filter()
+    : schedule_node() {}
+
+schedule_node_filter::schedule_node_filter(const schedule_node_filter &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_filter::schedule_node_filter(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_filter &schedule_node_filter::operator=(schedule_node_filter obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_filter::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::union_set schedule_node_filter::filter() const
 {
-  auto res = isl_schedule_node_reset_user(copy());
+  auto res = isl_schedule_node_filter_get_filter(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::root() const
+isl::union_set schedule_node_filter::get_filter() const
 {
-  auto res = isl_schedule_node_root(copy());
+  return filter();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_filter &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_guard
+schedule_node_guard::schedule_node_guard()
+    : schedule_node() {}
+
+schedule_node_guard::schedule_node_guard(const schedule_node_guard &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_guard::schedule_node_guard(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_guard &schedule_node_guard::operator=(schedule_node_guard obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_guard::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::set schedule_node_guard::guard() const
+{
+  auto res = isl_schedule_node_guard_get_guard(get());
   return manage(res);
 }
 
-isl::schedule_node schedule_node::sequence_splice_child(int pos) const
+isl::set schedule_node_guard::get_guard() const
+{
+  return guard();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_guard &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_leaf
+schedule_node_leaf::schedule_node_leaf()
+    : schedule_node() {}
+
+schedule_node_leaf::schedule_node_leaf(const schedule_node_leaf &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_leaf::schedule_node_leaf(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_leaf &schedule_node_leaf::operator=(schedule_node_leaf obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_leaf::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_leaf &obj)
 {
-  auto res = isl_schedule_node_sequence_splice_child(copy(), pos);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_mark
+schedule_node_mark::schedule_node_mark()
+    : schedule_node() {}
+
+schedule_node_mark::schedule_node_mark(const schedule_node_mark &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_mark::schedule_node_mark(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_mark &schedule_node_mark::operator=(schedule_node_mark obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_mark::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::id schedule_node_mark::id() const
+{
+  auto res = isl_schedule_node_mark_get_id(get());
   return manage(res);
 }
 
+isl::id schedule_node_mark::get_id() const
+{
+  return id();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_mark &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_sequence
+schedule_node_sequence::schedule_node_sequence()
+    : schedule_node() {}
+
+schedule_node_sequence::schedule_node_sequence(const schedule_node_sequence &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_sequence::schedule_node_sequence(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_sequence &schedule_node_sequence::operator=(schedule_node_sequence obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_sequence::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_sequence &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node_set
+schedule_node_set::schedule_node_set()
+    : schedule_node() {}
+
+schedule_node_set::schedule_node_set(const schedule_node_set &obj)
+    : schedule_node(obj)
+{
+}
+
+schedule_node_set::schedule_node_set(__isl_take isl_schedule_node *ptr)
+    : schedule_node(ptr) {}
+
+schedule_node_set &schedule_node_set::operator=(schedule_node_set obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx schedule_node_set::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_set &obj)
+{
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::set
 set manage(__isl_take isl_set *ptr) {
   return set(ptr);
 }
 set manage_copy(__isl_keep isl_set *ptr) {
   ptr = isl_set_copy(ptr);
   return set(ptr);
 }
 
 set::set()
     : ptr(nullptr) {}
 
 set::set(const set &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 set::set(__isl_take isl_set *ptr)
     : ptr(ptr) {}
 
 set::set(isl::basic_set bset)
 {
   auto res = isl_set_from_basic_set(bset.release());
   ptr = res;
 }
+
 set::set(isl::point pnt)
 {
   auto res = isl_set_from_point(pnt.release());
   ptr = res;
 }
+
 set::set(isl::union_set uset)
 {
   auto res = isl_set_from_union_set(uset.release());
   ptr = res;
 }
+
 set::set(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_set_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 set &set::operator=(set obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_set *set::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool set::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx set::ctx() const {
   return isl::ctx(isl_set_get_ctx(ptr));
 }
 
-void set::dump() const {
-  isl_set_dump(get());
-}
-
-
 isl::set set::add_constraint(isl::constraint constraint) const
 {
   auto res = isl_set_add_constraint(copy(), constraint.release());
   return manage(res);
 }
 
 isl::set set::add_dims(isl::dim type, unsigned int n) const
 {

 }
 
 isl::set set::apply(isl::map map) const
 {
   auto res = isl_set_apply(copy(), map.release());
   return manage(res);
 }
 
-isl::set set::bind(isl::multi_id tuple) const
+isl::union_set set::apply(const isl::union_map &umap) const
 {
-  auto res = isl_set_bind(copy(), tuple.release());
-  return manage(res);
+  return isl::union_set(*this).apply(umap);
 }
 
-isl::basic_set set::bounded_simple_hull() const
+isl::set set::apply(const isl::basic_map &map) const
 {
-  auto res = isl_set_bounded_simple_hull(copy());
-  return manage(res);
+  return this->apply(isl::map(map));
 }
 
-isl::set set::box_from_points(isl::point pnt1, isl::point pnt2)
+isl::pw_multi_aff set::as_pw_multi_aff() const
 {
-  auto res = isl_set_box_from_points(pnt1.release(), pnt2.release());
+  auto res = isl_set_as_pw_multi_aff(copy());
   return manage(res);
 }
 
-isl::set set::coalesce() const
+isl::set set::as_set() const
 {
-  auto res = isl_set_coalesce(copy());
-  return manage(res);
+  return isl::union_set(*this).as_set();
 }
 
-isl::basic_set set::coefficients() const
+isl::basic_set_list set::basic_set_list() const
 {
-  auto res = isl_set_coefficients(copy());
+  auto res = isl_set_get_basic_set_list(get());
   return manage(res);
 }
 
-isl::set set::complement() const
+isl::basic_set_list set::get_basic_set_list() const
 {
-  auto res = isl_set_complement(copy());
-  return manage(res);
+  return basic_set_list();
 }
 
-isl::basic_set set::convex_hull() const
+isl::set set::bind(isl::multi_id tuple) const
 {
-  auto res = isl_set_convex_hull(copy());
+  auto res = isl_set_bind(copy(), tuple.release());
   return manage(res);
 }
 
-isl::val set::count_val() const
+isl::set set::coalesce() const
 {
-  auto res = isl_set_count_val(get());
+  auto res = isl_set_coalesce(copy());
   return manage(res);
 }
 
-isl::set set::detect_equalities() const
+isl::set set::complement() const
 {
-  auto res = isl_set_detect_equalities(copy());
+  auto res = isl_set_complement(copy());
   return manage(res);
 }
 
-isl_size set::dim(isl::dim type) const
+isl::union_set set::compute_divs() const
 {
-  auto res = isl_set_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::union_set(*this).compute_divs();
 }
 
-boolean set::dim_has_any_lower_bound(isl::dim type, unsigned int pos) const
+boolean set::contains(const isl::space &space) const
 {
-  auto res = isl_set_dim_has_any_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
+  return isl::union_set(*this).contains(space);
+}
+
+isl::basic_set set::convex_hull() const
+{
+  auto res = isl_set_convex_hull(copy());
   return manage(res);
 }
 
-boolean set::dim_has_any_upper_bound(isl::dim type, unsigned int pos) const
+isl::set set::detect_equalities() const
 {
-  auto res = isl_set_dim_has_any_upper_bound(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_set_detect_equalities(copy());
   return manage(res);
 }
 
-boolean set::dim_has_lower_bound(isl::dim type, unsigned int pos) const
+class size set::dim(isl::dim type) const
 {
-  auto res = isl_set_dim_has_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_set_dim(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean set::dim_has_upper_bound(isl::dim type, unsigned int pos) const
+boolean set::dim_has_any_lower_bound(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_set_dim_has_upper_bound(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_set_dim_has_any_lower_bound(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-boolean set::dim_is_bounded(isl::dim type, unsigned int pos) const
+isl::id set::dim_id(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_set_dim_is_bounded(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_set_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
+isl::id set::get_dim_id(isl::dim type, unsigned int pos) const
+{
+  return dim_id(type, pos);
+}
+
 isl::pw_aff set::dim_max(int pos) const
 {
   auto res = isl_set_dim_max(copy(), pos);
   return manage(res);
 }
 
 isl::val set::dim_max_val(int pos) const
 {
   auto res = isl_set_dim_max_val(copy(), pos);
   return manage(res);
 }
 
 isl::pw_aff set::dim_min(int pos) const
 {
   auto res = isl_set_dim_min(copy(), pos);
   return manage(res);
 }
 
 isl::val set::dim_min_val(int pos) const
 {
   auto res = isl_set_dim_min_val(copy(), pos);
   return manage(res);
 }
 
-isl::set set::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+std::string set::dim_name(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_set_drop_constraints_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  auto res = isl_set_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
+  std::string tmp(res);
+  return tmp;
 }
 
-isl::set set::drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+std::string set::get_dim_name(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_set_drop_constraints_not_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return dim_name(type, pos);
 }
 
-isl::set set::drop_unused_params() const
+isl::set set::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_set_drop_unused_params(copy());
+  auto res = isl_set_drop_constraints_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::set set::eliminate(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_set_eliminate(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::set set::empty(isl::space space)
 {
   auto res = isl_set_empty(space.release());
   return manage(res);
 }
 
-isl::set set::equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const
+boolean set::every_set(const std::function<boolean(isl::set)> &test) const
 {
-  auto res = isl_set_equate(copy(), static_cast<enum isl_dim_type>(type1), pos1, static_cast<enum isl_dim_type>(type2), pos2);
-  return manage(res);
+  return isl::union_set(*this).every_set(test);
+}
+
+isl::set set::extract_set(const isl::space &space) const
+{
+  return isl::union_set(*this).extract_set(space);
 }
 
 int set::find_dim_by_id(isl::dim type, const isl::id &id) const
 {
   auto res = isl_set_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
   return res;
 }
 
-int set::find_dim_by_name(isl::dim type, const std::string &name) const
+int set::find_dim_by_id(isl::dim type, const std::string &id) const
 {
-  auto res = isl_set_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return this->find_dim_by_id(type, isl::id(ctx(), id));
 }
 
 isl::set set::fix_si(isl::dim type, unsigned int pos, int value) const
 {
   auto res = isl_set_fix_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
   return manage(res);
 }
 
-isl::set set::fix_val(isl::dim type, unsigned int pos, isl::val v) const
-{
-  auto res = isl_set_fix_val(copy(), static_cast<enum isl_dim_type>(type), pos, v.release());
-  return manage(res);
-}
-
-isl::set set::flat_product(isl::set set2) const
-{
-  auto res = isl_set_flat_product(copy(), set2.release());
-  return manage(res);
-}
-
 isl::set set::flatten() const
 {
   auto res = isl_set_flatten(copy());
   return manage(res);
 }
 
-isl::map set::flatten_map() const
-{
-  auto res = isl_set_flatten_map(copy());
-  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;
-}
-
-stat set::foreach_basic_set(const std::function<stat(basic_set)> &fn) const
+stat set::foreach_basic_set(const std::function<stat(isl::basic_set)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(basic_set)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_set_foreach_basic_set(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-stat set::foreach_point(const std::function<stat(point)> &fn) const
+stat set::foreach_point(const std::function<stat(isl::point)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(point)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_set_foreach_point(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::set set::from_multi_aff(isl::multi_aff ma)
-{
-  auto res = isl_set_from_multi_aff(ma.release());
-  return manage(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::from_params() const
-{
-  auto res = isl_set_from_params(copy());
-  return manage(res);
-}
-
-isl::set set::from_pw_aff(isl::pw_aff pwaff)
-{
-  auto res = isl_set_from_pw_aff(pwaff.release());
-  return manage(res);
-}
-
-isl::set set::from_pw_multi_aff(isl::pw_multi_aff pma)
-{
-  auto res = isl_set_from_pw_multi_aff(pma.release());
-  return manage(res);
-}
-
-isl::basic_set_list set::get_basic_set_list() const
-{
-  auto res = isl_set_get_basic_set_list(get());
-  return manage(res);
-}
-
-isl::id set::get_dim_id(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_set_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
-}
-
-std::string set::get_dim_name(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_set_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
-}
-
-isl::multi_val set::get_plain_multi_val_if_fixed() const
-{
-  auto res = isl_set_get_plain_multi_val_if_fixed(get());
-  return manage(res);
-}
-
-isl::fixed_box set::get_simple_fixed_box_hull() const
-{
-  auto res = isl_set_get_simple_fixed_box_hull(get());
-  return manage(res);
-}
-
-isl::space set::get_space() const
-{
-  auto res = isl_set_get_space(get());
-  return manage(res);
-}
-
-isl::val set::get_stride(int pos) const
-{
-  auto res = isl_set_get_stride(get(), pos);
-  return manage(res);
-}
-
-isl::id set::get_tuple_id() const
-{
-  auto res = isl_set_get_tuple_id(get());
-  return manage(res);
-}
-
-std::string set::get_tuple_name() const
+stat set::foreach_set(const std::function<stat(isl::set)> &fn) const
 {
-  auto res = isl_set_get_tuple_name(get());
-  std::string tmp(res);
-  return tmp;
+  return isl::union_set(*this).foreach_set(fn);
 }
 
 isl::set set::gist(isl::set context) const
 {
   auto res = isl_set_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::set set::gist_basic_set(isl::basic_set context) const
+isl::union_set set::gist(const isl::union_set &context) const
 {
-  auto res = isl_set_gist_basic_set(copy(), context.release());
-  return manage(res);
+  return isl::union_set(*this).gist(context);
 }
 
-isl::set set::gist_params(isl::set context) const
+isl::set set::gist(const isl::basic_set &context) const
 {
-  auto res = isl_set_gist_params(copy(), context.release());
-  return manage(res);
+  return this->gist(isl::set(context));
 }
 
-boolean set::has_dim_id(isl::dim type, unsigned int pos) const
+isl::set set::gist(const isl::point &context) const
 {
-  auto res = isl_set_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
+  return this->gist(isl::set(context));
 }
 
-boolean set::has_dim_name(isl::dim type, unsigned int pos) const
+isl::set set::gist_params(isl::set context) const
 {
-  auto res = isl_set_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_set_gist_params(copy(), context.release());
   return manage(res);
 }
 
 boolean set::has_equal_space(const isl::set &set2) const
 {
   auto res = isl_set_has_equal_space(get(), set2.get());
   return manage(res);
 }
 
-boolean set::has_tuple_id() const
+isl::map set::identity() const
 {
-  auto res = isl_set_has_tuple_id(get());
+  auto res = isl_set_identity(copy());
   return manage(res);
 }
 
-boolean set::has_tuple_name() const
+isl::union_pw_multi_aff set::identity_union_pw_multi_aff() const
 {
-  auto res = isl_set_has_tuple_name(get());
-  return manage(res);
-}
-
-isl::map set::identity() const
-{
-  auto res = isl_set_identity(copy());
-  return manage(res);
+  return isl::union_set(*this).identity_union_pw_multi_aff();
 }
 
 isl::pw_aff set::indicator_function() const
 {
   auto res = isl_set_indicator_function(copy());
   return manage(res);
 }
 

 }
 
 isl::set set::intersect(isl::set set2) const
 {
   auto res = isl_set_intersect(copy(), set2.release());
   return manage(res);
 }
 
-isl::set set::intersect_factor_domain(isl::set domain) const
+isl::union_set set::intersect(const isl::union_set &uset2) const
 {
-  auto res = isl_set_intersect_factor_domain(copy(), domain.release());
-  return manage(res);
+  return isl::union_set(*this).intersect(uset2);
 }
 
-isl::set set::intersect_factor_range(isl::set range) const
+isl::set set::intersect(const isl::basic_set &set2) const
 {
-  auto res = isl_set_intersect_factor_range(copy(), range.release());
-  return manage(res);
+  return this->intersect(isl::set(set2));
+}
+
+isl::set set::intersect(const isl::point &set2) const
+{
+  return this->intersect(isl::set(set2));
 }
 
 isl::set set::intersect_params(isl::set params) const
 {
   auto res = isl_set_intersect_params(copy(), params.release());
   return manage(res);
 }
 

 }
 
 boolean set::is_bounded() const
 {
   auto res = isl_set_is_bounded(get());
   return manage(res);
 }
 
-boolean set::is_box() const
+boolean set::is_disjoint(const isl::set &set2) const
 {
-  auto res = isl_set_is_box(get());
+  auto res = isl_set_is_disjoint(get(), set2.get());
   return manage(res);
 }
 
-boolean set::is_disjoint(const isl::set &set2) const
+boolean set::is_disjoint(const isl::union_set &uset2) const
 {
-  auto res = isl_set_is_disjoint(get(), set2.get());
-  return manage(res);
+  return isl::union_set(*this).is_disjoint(uset2);
+}
+
+boolean set::is_disjoint(const isl::basic_set &set2) const
+{
+  return this->is_disjoint(isl::set(set2));
+}
+
+boolean set::is_disjoint(const isl::point &set2) const
+{
+  return this->is_disjoint(isl::set(set2));
 }
 
 boolean set::is_empty() const
 {
   auto res = isl_set_is_empty(get());
   return manage(res);
 }
 
 boolean set::is_equal(const isl::set &set2) const
 {
   auto res = isl_set_is_equal(get(), set2.get());
   return manage(res);
 }
 
+boolean set::is_equal(const isl::union_set &uset2) const
+{
+  return isl::union_set(*this).is_equal(uset2);
+}
+
+boolean set::is_equal(const isl::basic_set &set2) const
+{
+  return this->is_equal(isl::set(set2));
+}
+
+boolean set::is_equal(const isl::point &set2) const
+{
+  return this->is_equal(isl::set(set2));
+}
+
 boolean set::is_params() const
 {
   auto res = isl_set_is_params(get());
   return manage(res);
 }
 
 boolean set::is_singleton() const
 {
   auto res = isl_set_is_singleton(get());
   return manage(res);
 }
 
 boolean set::is_strict_subset(const isl::set &set2) const
 {
   auto res = isl_set_is_strict_subset(get(), set2.get());
   return manage(res);
 }
 
+boolean set::is_strict_subset(const isl::union_set &uset2) const
+{
+  return isl::union_set(*this).is_strict_subset(uset2);
+}
+
+boolean set::is_strict_subset(const isl::basic_set &set2) const
+{
+  return this->is_strict_subset(isl::set(set2));
+}
+
+boolean set::is_strict_subset(const isl::point &set2) const
+{
+  return this->is_strict_subset(isl::set(set2));
+}
+
 boolean set::is_subset(const isl::set &set2) const
 {
   auto res = isl_set_is_subset(get(), set2.get());
   return manage(res);
 }
 
-boolean set::is_wrapping() const
+boolean set::is_subset(const isl::union_set &uset2) const
 {
-  auto res = isl_set_is_wrapping(get());
-  return manage(res);
+  return isl::union_set(*this).is_subset(uset2);
 }
 
-isl::map set::lex_ge_set(isl::set set2) const
+boolean set::is_subset(const isl::basic_set &set2) const
 {
-  auto res = isl_set_lex_ge_set(copy(), set2.release());
-  return manage(res);
+  return this->is_subset(isl::set(set2));
 }
 
-isl::map set::lex_gt_set(isl::set set2) const
+boolean set::is_subset(const isl::point &set2) const
 {
-  auto res = isl_set_lex_gt_set(copy(), set2.release());
-  return manage(res);
+  return this->is_subset(isl::set(set2));
 }
 
-isl::map set::lex_lt_set(isl::set set2) const
+boolean set::is_wrapping() const
 {
-  auto res = isl_set_lex_lt_set(copy(), set2.release());
+  auto res = isl_set_is_wrapping(get());
   return manage(res);
 }
 
+boolean set::isa_set() const
+{
+  return isl::union_set(*this).isa_set();
+}
+
 isl::set set::lexmax() const
 {
   auto res = isl_set_lexmax(copy());
   return manage(res);
 }
 
 isl::pw_multi_aff set::lexmax_pw_multi_aff() const
 {

 }
 
 isl::set set::lower_bound_val(isl::dim type, unsigned int pos, isl::val value) const
 {
   auto res = isl_set_lower_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
   return manage(res);
 }
 
+isl::set set::lower_bound_val(isl::dim type, unsigned int pos, long value) const
+{
+  return this->lower_bound_val(type, pos, isl::val(ctx(), value));
+}
+
 isl::multi_pw_aff set::max_multi_pw_aff() const
 {
   auto res = isl_set_max_multi_pw_aff(copy());
   return manage(res);
 }
 
 isl::val set::max_val(const isl::aff &obj) const
 {
   auto res = isl_set_max_val(get(), obj.get());
   return manage(res);
 }
 
 isl::multi_pw_aff set::min_multi_pw_aff() const
 {
   auto res = isl_set_min_multi_pw_aff(copy());
   return manage(res);
 }
 
 isl::val set::min_val(const isl::aff &obj) const
 {
   auto res = isl_set_min_val(get(), obj.get());
   return manage(res);
 }
 
-isl::set set::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_set_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_size set::n_basic_set() const
+class size set::n_basic_set() const
 {
   auto res = isl_set_n_basic_set(get());
-  return res;
-}
-
-isl_size set::n_dim() const
-{
-  auto res = isl_set_n_dim(get());
-  return res;
-}
-
-isl::set set::nat_universe(isl::space space)
-{
-  auto res = isl_set_nat_universe(space.release());
-  return manage(res);
-}
-
-isl::set set::neg() const
-{
-  auto res = isl_set_neg(copy());
   return manage(res);
 }
 
 isl::set set::params() const
 {
   auto res = isl_set_params(copy());
   return manage(res);
 }
 
-int set::plain_cmp(const isl::set &set2) const
-{
-  auto res = isl_set_plain_cmp(get(), set2.get());
-  return 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);
 }
 
-boolean set::plain_is_disjoint(const isl::set &set2) const
+isl::multi_val set::plain_multi_val_if_fixed() const
 {
-  auto res = isl_set_plain_is_disjoint(get(), set2.get());
-  return manage(res);
-}
-
-boolean set::plain_is_empty() const
-{
-  auto res = isl_set_plain_is_empty(get());
-  return manage(res);
-}
-
-boolean set::plain_is_equal(const isl::set &set2) const
-{
-  auto res = isl_set_plain_is_equal(get(), set2.get());
-  return manage(res);
-}
-
-boolean set::plain_is_universe() const
-{
-  auto res = isl_set_plain_is_universe(get());
+  auto res = isl_set_get_plain_multi_val_if_fixed(get());
   return manage(res);
 }
 
-isl::basic_set set::plain_unshifted_simple_hull() const
+isl::multi_val set::get_plain_multi_val_if_fixed() const
 {
-  auto res = isl_set_plain_unshifted_simple_hull(copy());
-  return manage(res);
+  return plain_multi_val_if_fixed();
 }
 
 isl::basic_set set::polyhedral_hull() const
 {
   auto res = isl_set_polyhedral_hull(copy());
   return manage(res);
 }
 

 }
 
 isl::set set::preimage(isl::pw_multi_aff pma) const
 {
   auto res = isl_set_preimage_pw_multi_aff(copy(), pma.release());
   return manage(res);
 }
 
-isl::set set::product(isl::set set2) const
+isl::union_set set::preimage(const isl::union_pw_multi_aff &upma) const
 {
-  auto res = isl_set_product(copy(), set2.release());
-  return manage(res);
+  return isl::union_set(*this).preimage(upma);
 }
 
-isl::map set::project_onto_map(isl::dim type, unsigned int first, unsigned int n) const
+isl::set set::product(isl::set set2) const
 {
-  auto res = isl_set_project_onto_map(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_set_product(copy(), set2.release());
   return manage(res);
 }
 
 isl::set set::project_out(isl::dim type, unsigned int first, unsigned int n) const
 {
   auto res = isl_set_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
 isl::set set::project_out_all_params() const
 {
   auto res = isl_set_project_out_all_params(copy());
   return manage(res);
 }
 
 isl::set set::project_out_param(isl::id id) const
 {
   auto res = isl_set_project_out_param_id(copy(), id.release());
   return manage(res);
 }
 
+isl::set set::project_out_param(const std::string &id) const
+{
+  return this->project_out_param(isl::id(ctx(), id));
+}
+
 isl::set set::project_out_param(isl::id_list list) const
 {
   auto res = isl_set_project_out_param_id_list(copy(), list.release());
   return manage(res);
 }
 
-isl::set set::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::pw_multi_aff set::pw_multi_aff_on_domain(isl::multi_val mv) const
 {
-  auto res = isl_set_remove_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_set_pw_multi_aff_on_domain_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-isl::set set::remove_divs() const
+isl::set set::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
 {
-  auto res = isl_set_remove_divs(copy());
+  auto res = isl_set_remove_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
   return manage(res);
 }
 
-isl::set set::remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::set set::remove_divs() const
 {
-  auto res = isl_set_remove_divs_involving_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_set_remove_divs(copy());
   return manage(res);
 }
 
 isl::set set::remove_redundancies() const
 {
   auto res = isl_set_remove_redundancies(copy());
   return manage(res);
 }
 
-isl::set set::remove_unknown_divs() const
-{
-  auto res = isl_set_remove_unknown_divs(copy());
-  return manage(res);
-}
-
-isl::set set::reset_space(isl::space space) const
-{
-  auto res = isl_set_reset_space(copy(), space.release());
-  return manage(res);
-}
-
 isl::set set::reset_tuple_id() const
 {
   auto res = isl_set_reset_tuple_id(copy());
   return manage(res);
 }
 
-isl::set set::reset_user() const
-{
-  auto res = isl_set_reset_user(copy());
-  return manage(res);
-}
-
 isl::basic_set set::sample() const
 {
   auto res = isl_set_sample(copy());
   return manage(res);
 }
 
 isl::point set::sample_point() const
 {
   auto res = isl_set_sample_point(copy());
   return manage(res);
 }
 
 isl::set set::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
 {
   auto res = isl_set_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
   return manage(res);
 }
 
+isl::set set::set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const
+{
+  return this->set_dim_id(type, pos, isl::id(ctx(), id));
+}
+
+isl::set_list set::set_list() const
+{
+  return isl::union_set(*this).set_list();
+}
+
 isl::set set::set_tuple_id(isl::id id) const
 {
   auto res = isl_set_set_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::set set::set_tuple_name(const std::string &s) const
+isl::set set::set_tuple_id(const std::string &id) const
 {
-  auto res = isl_set_set_tuple_name(copy(), s.c_str());
+  return this->set_tuple_id(isl::id(ctx(), id));
+}
+
+isl::fixed_box set::simple_fixed_box_hull() const
+{
+  auto res = isl_set_get_simple_fixed_box_hull(get());
   return manage(res);
 }
 
+isl::fixed_box set::get_simple_fixed_box_hull() const
+{
+  return simple_fixed_box_hull();
+}
+
 isl::basic_set set::simple_hull() const
 {
   auto res = isl_set_simple_hull(copy());
   return manage(res);
 }
 
-int set::size() const
+isl::space set::space() const
 {
-  auto res = isl_set_size(get());
-  return res;
+  auto res = isl_set_get_space(get());
+  return manage(res);
 }
 
-isl::basic_set set::solutions() const
+isl::space set::get_space() const
 {
-  auto res = isl_set_solutions(copy());
-  return manage(res);
+  return space();
 }
 
-isl::set set::split_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::val set::stride(int pos) const
 {
-  auto res = isl_set_split_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
+  auto res = isl_set_get_stride(get(), pos);
   return manage(res);
 }
 
+isl::val set::get_stride(int pos) const
+{
+  return stride(pos);
+}
+
 isl::set set::subtract(isl::set set2) const
 {
   auto res = isl_set_subtract(copy(), set2.release());
   return manage(res);
 }
 
-isl::set set::sum(isl::set set2) const
+isl::union_set set::subtract(const isl::union_set &uset2) const
+{
+  return isl::union_set(*this).subtract(uset2);
+}
+
+isl::set set::subtract(const isl::basic_set &set2) const
 {
-  auto res = isl_set_sum(copy(), set2.release());
+  return this->subtract(isl::set(set2));
+}
+
+isl::set set::subtract(const isl::point &set2) const
+{
+  return this->subtract(isl::set(set2));
+}
+
+isl::set_list set::to_list() const
+{
+  auto res = isl_set_to_list(copy());
+  return manage(res);
+}
+
+isl::union_set set::to_union_set() const
+{
+  auto res = isl_set_to_union_set(copy());
   return manage(res);
 }
 
 isl::map set::translation() const
 {
   auto res = isl_set_translation(copy());
   return manage(res);
 }
 
-isl_size set::tuple_dim() const
+class size set::tuple_dim() const
 {
   auto res = isl_set_tuple_dim(get());
-  return res;
+  return manage(res);
+}
+
+isl::id set::tuple_id() const
+{
+  auto res = isl_set_get_tuple_id(get());
+  return manage(res);
+}
+
+isl::id set::get_tuple_id() const
+{
+  return tuple_id();
+}
+
+std::string set::tuple_name() const
+{
+  auto res = isl_set_get_tuple_name(get());
+  std::string tmp(res);
+  return tmp;
+}
+
+std::string set::get_tuple_name() const
+{
+  return tuple_name();
 }
 
 isl::set set::unbind_params(isl::multi_id tuple) const
 {
   auto res = isl_set_unbind_params(copy(), tuple.release());
   return manage(res);
 }
 
 isl::map set::unbind_params_insert_domain(isl::multi_id domain) const
 {
   auto res = isl_set_unbind_params_insert_domain(copy(), domain.release());
   return manage(res);
 }
 
 isl::set set::unite(isl::set set2) const
 {
   auto res = isl_set_union(copy(), set2.release());
   return manage(res);
 }
 
+isl::union_set set::unite(const isl::union_set &uset2) const
+{
+  return isl::union_set(*this).unite(uset2);
+}
+
+isl::set set::unite(const isl::basic_set &set2) const
+{
+  return this->unite(isl::set(set2));
+}
+
+isl::set set::unite(const isl::point &set2) const
+{
+  return this->unite(isl::set(set2));
+}
+
 isl::set set::universe(isl::space space)
 {
   auto res = isl_set_universe(space.release());
   return manage(res);
 }
 
 isl::basic_set set::unshifted_simple_hull() const
 {
   auto res = isl_set_unshifted_simple_hull(copy());
   return manage(res);
 }
 
-isl::basic_set set::unshifted_simple_hull_from_set_list(isl::set_list list) const
-{
-  auto res = isl_set_unshifted_simple_hull_from_set_list(copy(), list.release());
-  return manage(res);
-}
-
 isl::map set::unwrap() const
 {
   auto res = isl_set_unwrap(copy());
   return manage(res);
 }
 
 isl::set set::upper_bound(isl::multi_pw_aff upper) const
 {
   auto res = isl_set_upper_bound_multi_pw_aff(copy(), upper.release());
   return manage(res);
 }
 
 isl::set set::upper_bound(isl::multi_val upper) const
 {
   auto res = isl_set_upper_bound_multi_val(copy(), upper.release());
   return manage(res);
 }
 
-isl::set set::upper_bound_si(isl::dim type, unsigned int pos, int value) const
+isl::set set::upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const
 {
-  auto res = isl_set_upper_bound_si(copy(), static_cast<enum isl_dim_type>(type), pos, value);
+  auto res = isl_set_upper_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
   return manage(res);
 }
 
-isl::set set::upper_bound_val(isl::dim type, unsigned int pos, isl::val value) const
+isl::set set::upper_bound_val(isl::dim type, unsigned int pos, long value) const
 {
-  auto res = isl_set_upper_bound_val(copy(), static_cast<enum isl_dim_type>(type), pos, value.release());
-  return manage(res);
+  return this->upper_bound_val(type, pos, isl::val(ctx(), value));
 }
 
-isl::map set::wrapped_domain_map() const
+inline std::ostream &operator<<(std::ostream &os, const set &obj)
 {
-  auto res = isl_set_wrapped_domain_map(copy());
-  return manage(res);
+  char *str = isl_set_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::set_list
 set_list manage(__isl_take isl_set_list *ptr) {
   return set_list(ptr);
 }
 set_list manage_copy(__isl_keep isl_set_list *ptr) {
   ptr = isl_set_list_copy(ptr);
   return set_list(ptr);
 }
 
 set_list::set_list()
     : ptr(nullptr) {}
 
 set_list::set_list(const set_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 set_list::set_list(__isl_take isl_set_list *ptr)
     : ptr(ptr) {}
 
+set_list::set_list(isl::ctx ctx, int n)
+{
+  auto res = isl_set_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+set_list::set_list(isl::set el)
+{
+  auto res = isl_set_list_from_set(el.release());
+  ptr = res;
+}
+
+set_list::set_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_set_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 set_list &set_list::operator=(set_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 set_list::~set_list() {
   if (ptr)
__isl_give isl_set_list *set_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool set_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx set_list::ctx() const {
   return isl::ctx(isl_set_list_get_ctx(ptr));
 }
 
-void set_list::dump() const {
-  isl_set_list_dump(get());
-}
-
-
 isl::set_list set_list::add(isl::set el) const
 {
   auto res = isl_set_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::set_list set_list::alloc(isl::ctx ctx, int n)
+isl::set set_list::at(int index) const
 {
-  auto res = isl_set_list_alloc(ctx.release(), n);
+  auto res = isl_set_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::set set_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::set_list set_list::clear() const
 {
   auto res = isl_set_list_clear(copy());
   return manage(res);
 }
 
 isl::set_list set_list::concat(isl::set_list list2) const
 {
   auto res = isl_set_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::set_list set_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_set_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat set_list::foreach(const std::function<stat(set)> &fn) const
+stat set_list::foreach(const std::function<stat(isl::set)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(set)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_set_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::set_list set_list::from_set(isl::set el)
-{
-  auto res = isl_set_list_from_set(el.release());
-  return manage(res);
-}
-
-isl::set set_list::get_at(int index) const
-{
-  auto res = isl_set_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::set set_list::get_set(int index) const
-{
-  auto res = isl_set_list_get_set(get(), index);
-  return manage(res);
-}
-
 isl::set_list set_list::insert(unsigned int pos, isl::set el) const
 {
   auto res = isl_set_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size set_list::n_set() const
-{
-  auto res = isl_set_list_n_set(get());
-  return res;
-}
-
-isl::set_list set_list::reverse() const
-{
-  auto res = isl_set_list_reverse(copy());
-  return manage(res);
-}
-
-isl::set_list set_list::set_set(int index, isl::set el) const
-{
-  auto res = isl_set_list_set_set(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size set_list::size() const
+class size set_list::size() const
 {
   auto res = isl_set_list_size(get());
-  return res;
-}
-
-isl::set_list set_list::swap(unsigned int pos1, unsigned int pos2) const
-{
-  auto res = isl_set_list_swap(copy(), pos1, pos2);
   return manage(res);
 }
 
-isl::set set_list::unite() const
+inline std::ostream &operator<<(std::ostream &os, const set_list &obj)
 {
-  auto res = isl_set_list_union(copy());
-  return manage(res);
+  char *str = isl_set_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::space
 space manage(__isl_take isl_space *ptr) {
   return space(ptr);
 }
 space manage_copy(__isl_keep isl_space *ptr) {
   ptr = isl_space_copy(ptr);
   return space(ptr);
 }
 
 space::space()
     : ptr(nullptr) {}
 
 space::space(const space &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 space::space(__isl_take isl_space *ptr)
     : ptr(ptr) {}
 
 space::space(isl::ctx ctx, unsigned int nparam, unsigned int n_in, unsigned int n_out)
 {
   auto res = isl_space_alloc(ctx.release(), nparam, n_in, n_out);
   ptr = res;
 }
+
 space::space(isl::ctx ctx, unsigned int nparam, unsigned int dim)
 {
   auto res = isl_space_set_alloc(ctx.release(), nparam, dim);
   ptr = res;
 }
 
 space &space::operator=(space obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_space *space::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool space::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx space::ctx() const {
   return isl::ctx(isl_space_get_ctx(ptr));
 }
 
-void space::dump() const {
-  isl_space_dump(get());
-}
-
-
 isl::space space::add_dims(isl::dim type, unsigned int n) const
 {
   auto res = isl_space_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
 }
 
 isl::space space::add_named_tuple(isl::id tuple_id, unsigned int dim) const
 {
   auto res = isl_space_add_named_tuple_id_ui(copy(), tuple_id.release(), dim);
   return manage(res);
 }
 
-isl::space space::add_param_id(isl::id id) const
-{
-  auto res = isl_space_add_param_id(copy(), id.release());
-  return manage(res);
-}
-
-isl::space space::add_unnamed_tuple(unsigned int dim) const
+isl::space space::add_named_tuple(const std::string &tuple_id, unsigned int dim) const
 {
-  auto res = isl_space_add_unnamed_tuple_ui(copy(), dim);
-  return manage(res);
+  return this->add_named_tuple(isl::id(ctx(), tuple_id), dim);
 }
 
-isl::space space::align_params(isl::space space2) const
+isl::space space::add_param(isl::id id) const
 {
-  auto res = isl_space_align_params(copy(), space2.release());
-  return manage(res);
-}
-
-boolean space::can_curry() const
-{
-  auto res = isl_space_can_curry(get());
+  auto res = isl_space_add_param_id(copy(), id.release());
   return manage(res);
 }
 
-boolean space::can_range_curry() const
+isl::space space::add_param(const std::string &id) const
 {
-  auto res = isl_space_can_range_curry(get());
-  return manage(res);
+  return this->add_param(isl::id(ctx(), id));
 }
 
-boolean space::can_uncurry() const
+isl::space space::add_unnamed_tuple(unsigned int dim) const
 {
-  auto res = isl_space_can_uncurry(get());
+  auto res = isl_space_add_unnamed_tuple_ui(copy(), dim);
   return manage(res);
 }
 
-boolean space::can_zip() const
+isl::space space::align_params(isl::space space2) const
 {
-  auto res = isl_space_can_zip(get());
+  auto res = isl_space_align_params(copy(), space2.release());
   return manage(res);
 }
 
 isl::space space::curry() const
 {
   auto res = isl_space_curry(copy());
   return manage(res);
 }
 
-isl_size space::dim(isl::dim type) const
+class size space::dim(isl::dim type) const
 {
   auto res = isl_space_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return manage(res);
 }
 
-isl::space space::domain() const
+isl::id space::dim_id(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_space_domain(copy());
+  auto res = isl_space_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
 }
 
-isl::space space::domain_factor_domain() const
+isl::id space::get_dim_id(isl::dim type, unsigned int pos) const
 {
-  auto res = isl_space_domain_factor_domain(copy());
-  return manage(res);
+  return dim_id(type, pos);
 }
 
-isl::space space::domain_factor_range() const
+isl::space space::domain() const
 {
-  auto res = isl_space_domain_factor_range(copy());
+  auto res = isl_space_domain(copy());
   return manage(res);
 }
 
-boolean space::domain_is_wrapping() const
+isl::multi_aff space::domain_map_multi_aff() const
 {
-  auto res = isl_space_domain_is_wrapping(get());
+  auto res = isl_space_domain_map_multi_aff(copy());
   return manage(res);
 }
 
-isl::space space::domain_map() const
+isl::pw_multi_aff space::domain_map_pw_multi_aff() const
 {
-  auto res = isl_space_domain_map(copy());
+  auto res = isl_space_domain_map_pw_multi_aff(copy());
   return manage(res);
 }
 
-isl::space space::domain_product(isl::space right) const
+isl::id space::domain_tuple_id() const
 {
-  auto res = isl_space_domain_product(copy(), right.release());
+  auto res = isl_space_get_domain_tuple_id(get());
   return manage(res);
 }
 
-isl::space space::drop_all_params() const
+isl::id space::get_domain_tuple_id() const
 {
-  auto res = isl_space_drop_all_params(copy());
-  return manage(res);
+  return domain_tuple_id();
 }
 
 isl::space space::drop_dims(isl::dim type, unsigned int first, unsigned int num) const
 {
   auto res = isl_space_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, num);
   return manage(res);
 }
 
-isl::space space::factor_domain() const
-{
-  auto res = isl_space_factor_domain(copy());
-  return manage(res);
-}
-
-isl::space space::factor_range() const
-{
-  auto res = isl_space_factor_range(copy());
-  return manage(res);
-}
-
 int space::find_dim_by_id(isl::dim type, const isl::id &id) const
 {
   auto res = isl_space_find_dim_by_id(get(), static_cast<enum isl_dim_type>(type), id.get());
   return res;
 }
 
-int space::find_dim_by_name(isl::dim type, const std::string &name) const
+int space::find_dim_by_id(isl::dim type, const std::string &id) const
 {
-  auto res = isl_space_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return this->find_dim_by_id(type, isl::id(ctx(), id));
 }
 
 isl::space space::flatten_domain() const
 {
   auto res = isl_space_flatten_domain(copy());
   return manage(res);
 }
 
 isl::space space::flatten_range() const
 {
   auto res = isl_space_flatten_range(copy());
   return manage(res);
 }
 
-isl::space space::from_domain() const
+boolean space::has_domain_tuple_id() const
 {
-  auto res = isl_space_from_domain(copy());
+  auto res = isl_space_has_domain_tuple_id(get());
   return manage(res);
 }
 
-isl::space space::from_range() const
-{
-  auto res = isl_space_from_range(copy());
-  return manage(res);
-}
-
-isl::id space::get_dim_id(isl::dim type, unsigned int pos) const
+boolean space::has_equal_tuples(const isl::space &space2) const
 {
-  auto res = isl_space_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_space_has_equal_tuples(get(), space2.get());
   return manage(res);
 }
 
-std::string space::get_dim_name(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_space_get_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
-  std::string tmp(res);
-  return tmp;
-}
-
-isl::id space::get_tuple_id(isl::dim type) const
+boolean space::has_range_tuple_id() const
 {
-  auto res = isl_space_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_space_has_range_tuple_id(get());
   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;
-}
-
-boolean space::has_dim_id(isl::dim type, unsigned int pos) const
+boolean space::has_tuple_id(isl::dim type) const
 {
-  auto res = isl_space_has_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_space_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean space::has_dim_name(isl::dim type, unsigned int pos) const
+boolean space::has_tuple_name(isl::dim type) const
 {
-  auto res = isl_space_has_dim_name(get(), static_cast<enum isl_dim_type>(type), pos);
+  auto res = isl_space_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
-boolean space::has_equal_params(const isl::space &space2) const
+isl::multi_aff space::identity_multi_aff_on_domain() const
 {
-  auto res = isl_space_has_equal_params(get(), space2.get());
+  auto res = isl_space_identity_multi_aff_on_domain(copy());
   return manage(res);
 }
 
-boolean space::has_equal_tuples(const isl::space &space2) const
+isl::multi_pw_aff space::identity_multi_pw_aff_on_domain() const
 {
-  auto res = isl_space_has_equal_tuples(get(), space2.get());
+  auto res = isl_space_identity_multi_pw_aff_on_domain(copy());
   return manage(res);
 }
 
-boolean space::has_tuple_id(isl::dim type) const
+isl::pw_multi_aff space::identity_pw_multi_aff_on_domain() const
 {
-  auto res = isl_space_has_tuple_id(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_space_identity_pw_multi_aff_on_domain(copy());
   return manage(res);
 }
 
-boolean space::has_tuple_name(isl::dim type) const
+boolean space::is_equal(const isl::space &space2) const
 {
-  auto res = isl_space_has_tuple_name(get(), static_cast<enum isl_dim_type>(type));
+  auto res = isl_space_is_equal(get(), space2.get());
   return manage(res);
 }
 
-isl::space space::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
+boolean space::is_params() const
 {
-  auto res = isl_space_insert_dims(copy(), static_cast<enum isl_dim_type>(type), pos, n);
+  auto res = isl_space_is_params(get());
   return manage(res);
 }
 
-boolean space::is_domain(const isl::space &space2) const
+boolean space::is_set() const
 {
-  auto res = isl_space_is_domain(get(), space2.get());
+  auto res = isl_space_is_set(get());
   return manage(res);
 }
 
-boolean space::is_equal(const isl::space &space2) const
+boolean space::is_wrapping() const
 {
-  auto res = isl_space_is_equal(get(), space2.get());
+  auto res = isl_space_is_wrapping(get());
   return manage(res);
 }
 
-boolean space::is_map() const
+isl::space space::map_from_domain_and_range(isl::space range) const
 {
-  auto res = isl_space_is_map(get());
+  auto res = isl_space_map_from_domain_and_range(copy(), range.release());
   return manage(res);
 }
 
-boolean space::is_params() const
+isl::space space::map_from_set() const
 {
-  auto res = isl_space_is_params(get());
+  auto res = isl_space_map_from_set(copy());
   return manage(res);
 }
 
-boolean space::is_product() const
+isl::multi_aff space::multi_aff(isl::aff_list list) const
 {
-  auto res = isl_space_is_product(get());
+  auto res = isl_space_multi_aff(copy(), list.release());
   return manage(res);
 }
 
-boolean space::is_range(const isl::space &space2) const
+isl::multi_aff space::multi_aff_on_domain(isl::multi_val mv) const
 {
-  auto res = isl_space_is_range(get(), space2.get());
+  auto res = isl_space_multi_aff_on_domain_multi_val(copy(), mv.release());
   return manage(res);
 }
 
-boolean space::is_set() const
+isl::multi_id space::multi_id(isl::id_list list) const
 {
-  auto res = isl_space_is_set(get());
+  auto res = isl_space_multi_id(copy(), list.release());
   return manage(res);
 }
 
-boolean space::is_wrapping() const
+isl::multi_pw_aff space::multi_pw_aff(isl::pw_aff_list list) const
 {
-  auto res = isl_space_is_wrapping(get());
+  auto res = isl_space_multi_pw_aff(copy(), list.release());
   return manage(res);
 }
 
-isl::space space::join(isl::space right) const
+isl::multi_union_pw_aff space::multi_union_pw_aff(isl::union_pw_aff_list list) const
 {
-  auto res = isl_space_join(copy(), right.release());
+  auto res = isl_space_multi_union_pw_aff(copy(), list.release());
   return manage(res);
 }
 
-isl::space space::map_from_domain_and_range(isl::space range) const
+isl::multi_val space::multi_val(isl::val_list list) const
 {
-  auto res = isl_space_map_from_domain_and_range(copy(), range.release());
+  auto res = isl_space_multi_val(copy(), list.release());
   return manage(res);
 }
 
-isl::space space::map_from_set() const
+isl::aff space::param_aff_on_domain(isl::id id) const
 {
-  auto res = isl_space_map_from_set(copy());
+  auto res = isl_space_param_aff_on_domain_id(copy(), id.release());
   return manage(res);
 }
 
-isl::space space::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
+isl::aff space::param_aff_on_domain(const std::string &id) const
 {
-  auto res = isl_space_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);
+  return this->param_aff_on_domain(isl::id(ctx(), id));
 }
 
 isl::space space::params() const
 {
   auto res = isl_space_params(copy());
   return manage(res);
 }
 

 }
 
 isl::space space::range() const
 {
   auto res = isl_space_range(copy());
   return manage(res);
 }
 
-isl::space space::range_curry() const
+isl::multi_aff space::range_map_multi_aff() const
 {
-  auto res = isl_space_range_curry(copy());
+  auto res = isl_space_range_map_multi_aff(copy());
   return manage(res);
 }
 
-isl::space space::range_factor_domain() const
+isl::pw_multi_aff space::range_map_pw_multi_aff() const
 {
-  auto res = isl_space_range_factor_domain(copy());
+  auto res = isl_space_range_map_pw_multi_aff(copy());
   return manage(res);
 }
 
-isl::space space::range_factor_range() const
+isl::space space::range_reverse() const
 {
-  auto res = isl_space_range_factor_range(copy());
+  auto res = isl_space_range_reverse(copy());
   return manage(res);
 }
 
-boolean space::range_is_wrapping() const
+isl::id space::range_tuple_id() const
 {
-  auto res = isl_space_range_is_wrapping(get());
+  auto res = isl_space_get_range_tuple_id(get());
   return manage(res);
 }
 
-isl::space space::range_map() const
+isl::id space::get_range_tuple_id() const
 {
-  auto res = isl_space_range_map(copy());
-  return manage(res);
+  return range_tuple_id();
 }
 
-isl::space space::range_product(isl::space right) const
+isl::space space::reverse() const
 {
-  auto res = isl_space_range_product(copy(), right.release());
+  auto res = isl_space_reverse(copy());
   return manage(res);
 }
 
-isl::space space::range_reverse() const
+isl::space space::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
 {
-  auto res = isl_space_range_reverse(copy());
+  auto res = isl_space_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
   return manage(res);
 }
 
-isl::space space::reset_tuple_id(isl::dim type) const
+isl::space space::set_dim_id(isl::dim type, unsigned int pos, const std::string &id) const
 {
-  auto res = isl_space_reset_tuple_id(copy(), static_cast<enum isl_dim_type>(type));
-  return manage(res);
+  return this->set_dim_id(type, pos, isl::id(ctx(), id));
 }
 
-isl::space space::reset_user() const
+isl::space space::set_domain_tuple(isl::id id) const
 {
-  auto res = isl_space_reset_user(copy());
+  auto res = isl_space_set_domain_tuple_id(copy(), id.release());
   return manage(res);
 }
 
-isl::space space::reverse() const
+isl::space space::set_domain_tuple(const std::string &id) const
 {
-  auto res = isl_space_reverse(copy());
-  return manage(res);
+  return this->set_domain_tuple(isl::id(ctx(), id));
 }
 
-isl::space space::set_dim_id(isl::dim type, unsigned int pos, isl::id id) const
+isl::space space::set_from_params() const
 {
-  auto res = isl_space_set_dim_id(copy(), static_cast<enum isl_dim_type>(type), pos, id.release());
+  auto res = isl_space_set_from_params(copy());
   return manage(res);
 }
 
-isl::space space::set_from_params() const
+isl::space space::set_range_tuple(isl::id id) const
 {
-  auto res = isl_space_set_from_params(copy());
+  auto res = isl_space_set_range_tuple_id(copy(), id.release());
   return manage(res);
 }
 
+isl::space space::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
 isl::space space::set_tuple_id(isl::dim type, isl::id id) const
 {
   auto res = isl_space_set_tuple_id(copy(), static_cast<enum isl_dim_type>(type), id.release());
   return manage(res);
 }
 
-isl::space space::set_tuple_name(isl::dim type, const std::string &s) const
+isl::space space::set_tuple_id(isl::dim type, const std::string &id) const
 {
-  auto res = isl_space_set_tuple_name(copy(), static_cast<enum isl_dim_type>(type), s.c_str());
-  return manage(res);
+  return this->set_tuple_id(type, isl::id(ctx(), id));
 }
 
-boolean space::tuple_is_equal(isl::dim type1, const isl::space &space2, isl::dim type2) const
+isl::id space::tuple_id(isl::dim type) 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));
+  auto res = isl_space_get_tuple_id(get(), static_cast<enum isl_dim_type>(type));
   return manage(res);
 }
 
+isl::id space::get_tuple_id(isl::dim type) const
+{
+  return tuple_id(type);
+}
+
+std::string space::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;
+}
+
+std::string space::get_tuple_name(isl::dim type) const
+{
+  return tuple_name(type);
+}
+
 isl::space space::uncurry() const
 {
   auto res = isl_space_uncurry(copy());
   return manage(res);
 }
 
 isl::space space::unit(isl::ctx ctx)
 {
   auto res = isl_space_unit(ctx.release());
   return manage(res);
 }
 
-isl::space space::unwrap() const
+isl::map space::universe_map() const
 {
-  auto res = isl_space_unwrap(copy());
+  auto res = isl_space_universe_map(copy());
   return manage(res);
 }
 
-isl::space space::wrap() const
+isl::set space::universe_set() const
 {
-  auto res = isl_space_wrap(copy());
+  auto res = isl_space_universe_set(copy());
   return manage(res);
 }
 
-isl::space space::zip() const
+isl::space space::unwrap() const
 {
-  auto res = isl_space_zip(copy());
+  auto res = isl_space_unwrap(copy());
   return manage(res);
 }
 
-// implementations for isl::term
-term manage(__isl_take isl_term *ptr) {
-  return term(ptr);
-}
-term manage_copy(__isl_keep isl_term *ptr) {
-  ptr = isl_term_copy(ptr);
-  return term(ptr);
-}
-
-term::term()
-    : ptr(nullptr) {}
-
-term::term(const term &obj)
-    : ptr(nullptr)
+isl::space space::wrap() const
 {
-  ptr = obj.copy();
-}
-
-
-term::term(__isl_take isl_term *ptr)
-    : ptr(ptr) {}
-
-
-term &term::operator=(term obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
-}
-
-term::~term() {
-  if (ptr)
-    isl_term_free(ptr);
-}
-
-__isl_give isl_term *term::copy() const & {
-  return isl_term_copy(ptr);
-}
-
-__isl_keep isl_term *term::get() const {
-  return ptr;
-}
-
-__isl_give isl_term *term::release() {
-  isl_term *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
+  auto res = isl_space_wrap(copy());
+  return manage(res);
 }
 
-bool term::is_null() const {
-  return ptr == nullptr;
+isl::aff space::zero_aff_on_domain() const
+{
+  auto res = isl_space_zero_aff_on_domain(copy());
+  return manage(res);
 }
 
-
-isl::ctx term::ctx() const {
-  return isl::ctx(isl_term_get_ctx(ptr));
+isl::multi_aff space::zero_multi_aff() const
+{
+  auto res = isl_space_zero_multi_aff(copy());
+  return manage(res);
 }
 
-
-isl_size term::dim(isl::dim type) const
+isl::multi_pw_aff space::zero_multi_pw_aff() const
 {
-  auto res = isl_term_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  auto res = isl_space_zero_multi_pw_aff(copy());
+  return manage(res);
 }
 
-isl::val term::get_coefficient_val() const
+isl::multi_union_pw_aff space::zero_multi_union_pw_aff() const
 {
-  auto res = isl_term_get_coefficient_val(get());
+  auto res = isl_space_zero_multi_union_pw_aff(copy());
   return manage(res);
 }
 
-isl::aff term::get_div(unsigned int pos) const
+isl::multi_val space::zero_multi_val() const
 {
-  auto res = isl_term_get_div(get(), pos);
+  auto res = isl_space_zero_multi_val(copy());
   return manage(res);
 }
 
-isl_size term::get_exp(isl::dim type, unsigned int pos) const
+inline std::ostream &operator<<(std::ostream &os, const space &obj)
 {
-  auto res = isl_term_get_exp(get(), static_cast<enum isl_dim_type>(type), pos);
-  return res;
+  char *str = isl_space_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::union_access_info
 union_access_info manage(__isl_take isl_union_access_info *ptr) {
   return union_access_info(ptr);
 }
 union_access_info manage_copy(__isl_keep isl_union_access_info *ptr) {
   ptr = isl_union_access_info_copy(ptr);
   return union_access_info(ptr);
 }
 
 union_access_info::union_access_info()
     : ptr(nullptr) {}
 
 union_access_info::union_access_info(const union_access_info &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_access_info::union_access_info(__isl_take isl_union_access_info *ptr)
     : ptr(ptr) {}
 
 union_access_info::union_access_info(isl::union_map sink)
 {
   auto res = isl_union_access_info_from_sink(sink.release());
   ptr = res;
 }
__isl_give isl_union_access_info *union_access_info::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_access_info::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_access_info::ctx() const {
   return isl::ctx(isl_union_access_info_get_ctx(ptr));
 }
 
-
 isl::union_flow union_access_info::compute_flow() const
 {
   auto res = isl_union_access_info_compute_flow(copy());
   return manage(res);
 }
 
 isl::union_access_info union_access_info::set_kill(isl::union_map kill) const
 {

 }
 
 isl::union_access_info union_access_info::set_schedule_map(isl::union_map schedule_map) const
 {
   auto res = isl_union_access_info_set_schedule_map(copy(), schedule_map.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const union_access_info &obj)
+{
+  char *str = isl_union_access_info_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::union_flow
 union_flow manage(__isl_take isl_union_flow *ptr) {
   return union_flow(ptr);
 }
 union_flow manage_copy(__isl_keep isl_union_flow *ptr) {
   ptr = isl_union_flow_copy(ptr);
   return union_flow(ptr);
 }
 
 union_flow::union_flow()
     : ptr(nullptr) {}
 
 union_flow::union_flow(const union_flow &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_flow::union_flow(__isl_take isl_union_flow *ptr)
     : ptr(ptr) {}
 
-
 union_flow &union_flow::operator=(union_flow obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 union_flow::~union_flow() {
   if (ptr)
     isl_union_flow_free(ptr);
__isl_give isl_union_flow *union_flow::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_flow::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_flow::ctx() const {
   return isl::ctx(isl_union_flow_get_ctx(ptr));
 }
 
-
-isl::union_map union_flow::get_full_may_dependence() const
+isl::union_map union_flow::full_may_dependence() const
 {
   auto res = isl_union_flow_get_full_may_dependence(get());
   return manage(res);
 }
 
-isl::union_map union_flow::get_full_must_dependence() const
+isl::union_map union_flow::get_full_may_dependence() const
+{
+  return full_may_dependence();
+}
+
+isl::union_map union_flow::full_must_dependence() const
 {
   auto res = isl_union_flow_get_full_must_dependence(get());
   return manage(res);
 }
 
-isl::union_map union_flow::get_may_dependence() const
+isl::union_map union_flow::get_full_must_dependence() const
+{
+  return full_must_dependence();
+}
+
+isl::union_map union_flow::may_dependence() const
 {
   auto res = isl_union_flow_get_may_dependence(get());
   return manage(res);
 }
 
-isl::union_map union_flow::get_may_no_source() const
+isl::union_map union_flow::get_may_dependence() const
+{
+  return may_dependence();
+}
+
+isl::union_map union_flow::may_no_source() const
 {
   auto res = isl_union_flow_get_may_no_source(get());
   return manage(res);
 }
 
-isl::union_map union_flow::get_must_dependence() const
+isl::union_map union_flow::get_may_no_source() const
+{
+  return may_no_source();
+}
+
+isl::union_map union_flow::must_dependence() const
 {
   auto res = isl_union_flow_get_must_dependence(get());
   return manage(res);
 }
 
-isl::union_map union_flow::get_must_no_source() const
+isl::union_map union_flow::get_must_dependence() const
+{
+  return must_dependence();
+}
+
+isl::union_map union_flow::must_no_source() const
 {
   auto res = isl_union_flow_get_must_no_source(get());
   return manage(res);
 }
 
+isl::union_map union_flow::get_must_no_source() const
+{
+  return must_no_source();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_flow &obj)
+{
+  char *str = isl_union_flow_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::union_map
 union_map manage(__isl_take isl_union_map *ptr) {
   return union_map(ptr);
 }
 union_map manage_copy(__isl_keep isl_union_map *ptr) {
   ptr = isl_union_map_copy(ptr);
   return union_map(ptr);
 }
 
 union_map::union_map()
     : ptr(nullptr) {}
 
 union_map::union_map(const union_map &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_map::union_map(__isl_take isl_union_map *ptr)
     : ptr(ptr) {}
 
 union_map::union_map(isl::basic_map bmap)
 {
   auto res = isl_union_map_from_basic_map(bmap.release());
   ptr = res;
 }
+
 union_map::union_map(isl::map map)
 {
   auto res = isl_union_map_from_map(map.release());
   ptr = res;
 }
-union_map::union_map(isl::union_pw_multi_aff upma)
-{
-  auto res = isl_union_map_from_union_pw_multi_aff(upma.release());
-  ptr = res;
-}
+
 union_map::union_map(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_union_map_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 union_map &union_map::operator=(union_map obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_union_map *union_map::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_map::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_map::ctx() const {
   return isl::ctx(isl_union_map_get_ctx(ptr));
 }
 
-void union_map::dump() const {
-  isl_union_map_dump(get());
+isl::union_map union_map::affine_hull() const
+{
+  auto res = isl_union_map_affine_hull(copy());
+  return manage(res);
 }
 
+isl::union_map union_map::apply_domain(isl::union_map umap2) const
+{
+  auto res = isl_union_map_apply_domain(copy(), umap2.release());
+  return manage(res);
+}
 
-isl::union_map union_map::affine_hull() const
+isl::union_map union_map::apply_range(isl::union_map umap2) const
 {
-  auto res = isl_union_map_affine_hull(copy());
+  auto res = isl_union_map_apply_range(copy(), umap2.release());
   return manage(res);
 }
 
-isl::union_map union_map::align_params(isl::space model) const
+isl::map union_map::as_map() const
 {
-  auto res = isl_union_map_align_params(copy(), model.release());
+  auto res = isl_union_map_as_map(copy());
   return manage(res);
 }
 
-isl::union_map union_map::apply_domain(isl::union_map umap2) const
+isl::multi_union_pw_aff union_map::as_multi_union_pw_aff() const
 {
-  auto res = isl_union_map_apply_domain(copy(), umap2.release());
+  auto res = isl_union_map_as_multi_union_pw_aff(copy());
   return manage(res);
 }
 
-isl::union_map union_map::apply_range(isl::union_map umap2) const
+isl::union_pw_multi_aff union_map::as_union_pw_multi_aff() const
 {
-  auto res = isl_union_map_apply_range(copy(), umap2.release());
+  auto res = isl_union_map_as_union_pw_multi_aff(copy());
   return manage(res);
 }
 
 isl::union_set union_map::bind_range(isl::multi_id tuple) const
 {
   auto res = isl_union_map_bind_range(copy(), tuple.release());
   return manage(res);
 }
 
 isl::union_map union_map::coalesce() const
 {
   auto res = isl_union_map_coalesce(copy());
   return manage(res);
 }
 
-boolean union_map::contains(const isl::space &space) const
+isl::union_map union_map::compute_divs() const
 {
-  auto res = isl_union_map_contains(get(), space.get());
+  auto res = isl_union_map_compute_divs(copy());
   return manage(res);
 }
 
 isl::union_map union_map::curry() const
 {
   auto res = isl_union_map_curry(copy());
   return manage(res);
 }
 
 isl::union_set union_map::deltas() const
 {
   auto res = isl_union_map_deltas(copy());
   return manage(res);
 }
 
-isl::union_map union_map::deltas_map() const
-{
-  auto res = isl_union_map_deltas_map(copy());
-  return manage(res);
-}
-
 isl::union_map union_map::detect_equalities() const
 {
   auto res = isl_union_map_detect_equalities(copy());
   return manage(res);
 }
 
-isl_size union_map::dim(isl::dim type) const
-{
-  auto res = isl_union_map_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
-}
-
 isl::union_set union_map::domain() const
 {
   auto res = isl_union_map_domain(copy());
   return manage(res);
 }
 
 isl::union_map union_map::domain_factor_domain() const
 {

 }
 
 isl::union_map union_map::eq_at(isl::multi_union_pw_aff mupa) const
 {
   auto res = isl_union_map_eq_at_multi_union_pw_aff(copy(), mupa.release());
   return manage(res);
 }
 
+boolean union_map::every_map(const std::function<boolean(isl::map)> &test) const
+{
+  struct test_data {
+    std::function<boolean(isl::map)> func;
+  } test_data = { test };
+  auto test_lambda = [](isl_map *arg_0, void *arg_1) -> isl_bool {
+    auto *data = static_cast<struct test_data *>(arg_1);
+    auto ret = (data->func)(manage_copy(arg_0));
+    return ret.release();
+  };
+  auto res = isl_union_map_every_map(get(), test_lambda, &test_data);
+  return manage(res);
+}
+
 isl::map union_map::extract_map(isl::space space) const
 {
   auto res = isl_union_map_extract_map(get(), space.release());
   return manage(res);
 }
 
 isl::union_map union_map::factor_domain() const
 {
   auto res = isl_union_map_factor_domain(copy());
   return manage(res);
 }
 
 isl::union_map union_map::factor_range() const
 {
   auto res = isl_union_map_factor_range(copy());
   return manage(res);
 }
 
-int union_map::find_dim_by_name(isl::dim type, const std::string &name) const
-{
-  auto res = isl_union_map_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
-}
-
 isl::union_map union_map::fixed_power(isl::val exp) const
 {
   auto res = isl_union_map_fixed_power_val(copy(), exp.release());
   return manage(res);
 }
 
-isl::union_map union_map::flat_domain_product(isl::union_map umap2) const
+isl::union_map union_map::fixed_power(long exp) const
 {
-  auto res = isl_union_map_flat_domain_product(copy(), umap2.release());
-  return manage(res);
+  return this->fixed_power(isl::val(ctx(), exp));
 }
 
 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);
 }
 
-stat union_map::foreach_map(const std::function<stat(map)> &fn) const
+stat union_map::foreach_map(const std::function<stat(isl::map)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(map)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_union_map_foreach_map(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
 isl::union_map union_map::from(isl::multi_union_pw_aff mupa)
 {
   auto res = isl_union_map_from_multi_union_pw_aff(mupa.release());
   return manage(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::from_domain(isl::union_set uset)
 {
   auto res = isl_union_map_from_domain(uset.release());
   return manage(res);
 }
 
 isl::union_map union_map::from_domain_and_range(isl::union_set domain, isl::union_set range)
 {
   auto res = isl_union_map_from_domain_and_range(domain.release(), range.release());
   return manage(res);
 }
 
 isl::union_map union_map::from_range(isl::union_set uset)
 {
   auto res = isl_union_map_from_range(uset.release());
   return manage(res);
 }
 
-isl::union_map union_map::from_union_pw_aff(isl::union_pw_aff upa)
-{
-  auto res = isl_union_map_from_union_pw_aff(upa.release());
-  return manage(res);
-}
-
-isl::id union_map::get_dim_id(isl::dim type, unsigned int pos) const
-{
-  auto res = isl_union_map_get_dim_id(get(), static_cast<enum isl_dim_type>(type), pos);
-  return manage(res);
-}
-
-uint32_t union_map::get_hash() const
-{
-  auto res = isl_union_map_get_hash(get());
-  return res;
-}
-
-isl::map_list union_map::get_map_list() const
-{
-  auto res = isl_union_map_get_map_list(get());
-  return manage(res);
-}
-
-isl::space union_map::get_space() const
-{
-  auto res = isl_union_map_get_space(get());
-  return manage(res);
-}
-
 isl::union_map union_map::gist(isl::union_map context) const
 {
   auto res = isl_union_map_gist(copy(), context.release());
   return manage(res);
 }
 
 isl::union_map union_map::gist_domain(isl::union_set uset) const
 {

 }
 
 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);
 }
 
-boolean union_map::involves_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_map_involves_dims(get(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
 boolean union_map::is_bijective() const
 {
   auto res = isl_union_map_is_bijective(get());
   return manage(res);
 }
 
 boolean union_map::is_disjoint(const isl::union_map &umap2) const
 {
   auto res = isl_union_map_is_disjoint(get(), umap2.get());
   return manage(res);
 }
 
 boolean union_map::is_empty() const
 {
   auto res = isl_union_map_is_empty(get());
   return manage(res);
 }
 
 boolean union_map::is_equal(const isl::union_map &umap2) const
 {
   auto res = isl_union_map_is_equal(get(), umap2.get());
   return manage(res);
 }
 
-boolean union_map::is_identity() const
-{
-  auto res = isl_union_map_is_identity(get());
-  return manage(res);
-}
-
 boolean union_map::is_injective() const
 {
   auto res = isl_union_map_is_injective(get());
   return manage(res);
 }
 
 boolean union_map::is_single_valued() const
 {

 }
 
 boolean union_map::isa_map() const
 {
   auto res = isl_union_map_isa_map(get());
   return manage(res);
 }
 
-isl::union_map union_map::lex_ge_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) const
-{
-  auto res = isl_union_map_lex_ge_at_multi_union_pw_aff(copy(), mupa.release());
-  return manage(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::union_map union_map::lex_gt_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) const
-{
-  auto res = isl_union_map_lex_gt_at_multi_union_pw_aff(copy(), mupa.release());
-  return manage(res);
-}
-
-isl::union_map union_map::lex_gt_union_map(isl::union_map umap2) const
-{
-  auto res = isl_union_map_lex_gt_union_map(copy(), umap2.release());
-  return manage(res);
-}
-
-isl::union_map union_map::lex_le_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) const
-{
-  auto res = isl_union_map_lex_le_at_multi_union_pw_aff(copy(), mupa.release());
-  return manage(res);
-}
-
-isl::union_map union_map::lex_le_union_map(isl::union_map umap2) const
-{
-  auto res = isl_union_map_lex_le_union_map(copy(), umap2.release());
-  return manage(res);
-}
-
-isl::union_map union_map::lex_lt_at_multi_union_pw_aff(isl::multi_union_pw_aff mupa) const
-{
-  auto res = isl_union_map_lex_lt_at_multi_union_pw_aff(copy(), mupa.release());
-  return manage(res);
-}
-
-isl::union_map union_map::lex_lt_union_map(isl::union_map umap2) const
-{
-  auto res = isl_union_map_lex_lt_union_map(copy(), umap2.release());
-  return manage(res);
-}
-
 isl::union_map union_map::lexmax() const
 {
   auto res = isl_union_map_lexmax(copy());
   return manage(res);
 }
 
 isl::union_map union_map::lexmin() const
 {
   auto res = isl_union_map_lexmin(copy());
   return manage(res);
 }
 
-isl_size union_map::n_map() const
-{
-  auto res = isl_union_map_n_map(get());
-  return res;
-}
-
-isl::set union_map::params() const
+isl::map_list union_map::map_list() const
 {
-  auto res = isl_union_map_params(copy());
+  auto res = isl_union_map_get_map_list(get());
   return manage(res);
 }
 
-boolean union_map::plain_is_empty() const
+isl::map_list union_map::get_map_list() const
 {
-  auto res = isl_union_map_plain_is_empty(get());
-  return manage(res);
+  return map_list();
 }
 
-boolean union_map::plain_is_injective() const
+isl::set union_map::params() const
 {
-  auto res = isl_union_map_plain_is_injective(get());
+  auto res = isl_union_map_params(copy());
   return manage(res);
 }
 
 isl::union_map union_map::polyhedral_hull() const
 {
   auto res = isl_union_map_polyhedral_hull(copy());
   return manage(res);
 }

 }
 
 isl::union_map union_map::product(isl::union_map umap2) const
 {
   auto res = isl_union_map_product(copy(), umap2.release());
   return manage(res);
 }
 
-isl::union_map union_map::project_out(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_map_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
 isl::union_map union_map::project_out_all_params() const
 {
   auto res = isl_union_map_project_out_all_params(copy());
   return manage(res);
 }
 
 isl::union_set union_map::range() const
 {
   auto res = isl_union_map_range(copy());
   return manage(res);
 }
 
-isl::union_map union_map::range_curry() const
-{
-  auto res = isl_union_map_range_curry(copy());
-  return manage(res);
-}
-
 isl::union_map union_map::range_factor_domain() const
 {
   auto res = isl_union_map_range_factor_domain(copy());
   return manage(res);
 }
 
 isl::union_map union_map::range_factor_range() const
 {

 }
 
 isl::union_map union_map::range_reverse() const
 {
   auto res = isl_union_map_range_reverse(copy());
   return manage(res);
 }
 
-isl::union_map union_map::remove_divs() const
-{
-  auto res = isl_union_map_remove_divs(copy());
-  return manage(res);
-}
-
-isl::union_map union_map::remove_redundancies() const
-{
-  auto res = isl_union_map_remove_redundancies(copy());
-  return manage(res);
-}
-
-isl::union_map union_map::reset_user() const
-{
-  auto res = isl_union_map_reset_user(copy());
-  return manage(res);
-}
-
 isl::union_map union_map::reverse() const
 {
   auto res = isl_union_map_reverse(copy());
   return manage(res);
 }
 
-isl::basic_map union_map::sample() const
+isl::space union_map::space() const
 {
-  auto res = isl_union_map_sample(copy());
+  auto res = isl_union_map_get_space(get());
   return manage(res);
 }
 
-isl::union_map union_map::simple_hull() const
+isl::space union_map::get_space() const
 {
-  auto res = isl_union_map_simple_hull(copy());
-  return manage(res);
+  return space();
 }
 
 isl::union_map union_map::subtract(isl::union_map umap2) const
 {
   auto res = isl_union_map_subtract(copy(), umap2.release());
   return manage(res);
 }
 

 }
 
 isl::union_map union_map::zip() const
 {
   auto res = isl_union_map_zip(copy());
   return manage(res);
 }
 
-// implementations for isl::union_map_list
-union_map_list manage(__isl_take isl_union_map_list *ptr) {
-  return union_map_list(ptr);
-}
-union_map_list manage_copy(__isl_keep isl_union_map_list *ptr) {
-  ptr = isl_union_map_list_copy(ptr);
-  return union_map_list(ptr);
-}
-
-union_map_list::union_map_list()
-    : ptr(nullptr) {}
-
-union_map_list::union_map_list(const union_map_list &obj)
-    : ptr(nullptr)
-{
-  ptr = obj.copy();
-}
-
-
-union_map_list::union_map_list(__isl_take isl_union_map_list *ptr)
-    : ptr(ptr) {}
-
-
-union_map_list &union_map_list::operator=(union_map_list obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
-}
-
-union_map_list::~union_map_list() {
-  if (ptr)
-    isl_union_map_list_free(ptr);
-}
-
-__isl_give isl_union_map_list *union_map_list::copy() const & {
-  return isl_union_map_list_copy(ptr);
-}
-
-__isl_keep isl_union_map_list *union_map_list::get() const {
-  return ptr;
-}
-
-__isl_give isl_union_map_list *union_map_list::release() {
-  isl_union_map_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
-}
-
-bool union_map_list::is_null() const {
-  return ptr == nullptr;
-}
-
-
-isl::ctx union_map_list::ctx() const {
-  return isl::ctx(isl_union_map_list_get_ctx(ptr));
-}
-
-void union_map_list::dump() const {
-  isl_union_map_list_dump(get());
-}
-
-
-isl::union_map_list union_map_list::add(isl::union_map el) const
-{
-  auto res = isl_union_map_list_add(copy(), el.release());
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::alloc(isl::ctx ctx, int n)
-{
-  auto res = isl_union_map_list_alloc(ctx.release(), n);
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::clear() const
-{
-  auto res = isl_union_map_list_clear(copy());
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::concat(isl::union_map_list list2) const
-{
-  auto res = isl_union_map_list_concat(copy(), list2.release());
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::drop(unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_map_list_drop(copy(), first, n);
-  return manage(res);
-}
-
-stat union_map_list::foreach(const std::function<stat(union_map)> &fn) const
-{
-  struct fn_data {
-    const std::function<stat(union_map)> *func;
-  } fn_data = { &fn };
-  auto fn_lambda = [](isl_union_map *arg_0, void *arg_1) -> isl_stat {
-    auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_union_map_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::from_union_map(isl::union_map el)
-{
-  auto res = isl_union_map_list_from_union_map(el.release());
-  return manage(res);
-}
-
-isl::union_map union_map_list::get_at(int index) const
-{
-  auto res = isl_union_map_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::union_map union_map_list::get_union_map(int index) const
-{
-  auto res = isl_union_map_list_get_union_map(get(), index);
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::insert(unsigned int pos, isl::union_map el) const
-{
-  auto res = isl_union_map_list_insert(copy(), pos, el.release());
-  return manage(res);
-}
-
-isl_size union_map_list::n_union_map() const
-{
-  auto res = isl_union_map_list_n_union_map(get());
-  return res;
-}
-
-isl::union_map_list union_map_list::reverse() const
-{
-  auto res = isl_union_map_list_reverse(copy());
-  return manage(res);
-}
-
-isl::union_map_list union_map_list::set_union_map(int index, isl::union_map el) const
+inline std::ostream &operator<<(std::ostream &os, const union_map &obj)
 {
-  auto res = isl_union_map_list_set_union_map(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size union_map_list::size() const
-{
-  auto res = isl_union_map_list_size(get());
-  return res;
-}
-
-isl::union_map_list union_map_list::swap(unsigned int pos1, unsigned int pos2) const
-{
-  auto res = isl_union_map_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_union_map_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::union_pw_aff
 union_pw_aff manage(__isl_take isl_union_pw_aff *ptr) {
   return union_pw_aff(ptr);
 }
 union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr) {
   ptr = isl_union_pw_aff_copy(ptr);
   return union_pw_aff(ptr);
 }
 
 union_pw_aff::union_pw_aff()
     : ptr(nullptr) {}
 
 union_pw_aff::union_pw_aff(const union_pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_pw_aff::union_pw_aff(__isl_take isl_union_pw_aff *ptr)
     : ptr(ptr) {}
 
 union_pw_aff::union_pw_aff(isl::aff aff)
 {
   auto res = isl_union_pw_aff_from_aff(aff.release());
   ptr = res;
 }
+
 union_pw_aff::union_pw_aff(isl::pw_aff pa)
 {
   auto res = isl_union_pw_aff_from_pw_aff(pa.release());
   ptr = res;
 }
+
 union_pw_aff::union_pw_aff(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_union_pw_aff_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
+
 union_pw_aff::union_pw_aff(isl::union_set domain, isl::val v)
 {
   auto res = isl_union_pw_aff_val_on_domain(domain.release(), v.release());
   ptr = res;
 }
 
 union_pw_aff &union_pw_aff::operator=(union_pw_aff obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_union_pw_aff *union_pw_aff::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_pw_aff::ctx() const {
   return isl::ctx(isl_union_pw_aff_get_ctx(ptr));
 }
 
-void union_pw_aff::dump() const {
-  isl_union_pw_aff_dump(get());
+isl::multi_union_pw_aff union_pw_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::multi_union_pw_aff(*this).add(multi2);
 }
 
-
 isl::union_pw_aff union_pw_aff::add(isl::union_pw_aff upa2) const
 {
   auto res = isl_union_pw_aff_add(copy(), upa2.release());
   return manage(res);
 }
 
-isl::union_pw_aff union_pw_aff::add_pw_aff(isl::pw_aff pa) const
+isl::union_pw_multi_aff union_pw_aff::add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_union_pw_aff_add_pw_aff(copy(), pa.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).add(upma2);
 }
 
-isl::union_pw_aff union_pw_aff::aff_on_domain(isl::union_set domain, isl::aff aff)
+isl::union_pw_aff union_pw_aff::add(const isl::aff &upa2) const
 {
-  auto res = isl_union_pw_aff_aff_on_domain(domain.release(), aff.release());
-  return manage(res);
+  return this->add(isl::union_pw_aff(upa2));
 }
 
-isl::union_pw_aff union_pw_aff::align_params(isl::space model) const
+isl::union_pw_aff union_pw_aff::add(const isl::pw_aff &upa2) const
 {
-  auto res = isl_union_pw_aff_align_params(copy(), model.release());
-  return manage(res);
+  return this->add(isl::union_pw_aff(upa2));
 }
 
-isl::union_set union_pw_aff::bind(isl::id id) const
+isl::union_pw_multi_aff union_pw_aff::add_pw_multi_aff(const isl::pw_multi_aff &pma) const
 {
-  auto res = isl_union_pw_aff_bind_id(copy(), id.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).add_pw_multi_aff(pma);
 }
 
-isl::union_pw_aff union_pw_aff::coalesce() const
+isl::union_pw_multi_aff union_pw_aff::apply(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_union_pw_aff_coalesce(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).apply(upma2);
 }
 
-isl_size union_pw_aff::dim(isl::dim type) const
+isl::multi_union_pw_aff union_pw_aff::as_multi_union_pw_aff() const
 {
-  auto res = isl_union_pw_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  return isl::union_pw_multi_aff(*this).as_multi_union_pw_aff();
 }
 
-isl::union_set union_pw_aff::domain() const
+isl::pw_multi_aff union_pw_aff::as_pw_multi_aff() const
 {
-  auto res = isl_union_pw_aff_domain(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).as_pw_multi_aff();
 }
 
-isl::union_pw_aff union_pw_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
+isl::union_map union_pw_aff::as_union_map() const
 {
-  auto res = isl_union_pw_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).as_union_map();
 }
 
-isl::union_pw_aff union_pw_aff::empty(isl::space space)
+isl::union_pw_aff union_pw_aff::at(int pos) const
 {
-  auto res = isl_union_pw_aff_empty(space.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).at(pos);
 }
 
-isl::union_pw_aff union_pw_aff::empty_ctx(isl::ctx ctx)
+isl::union_set union_pw_aff::bind(const isl::multi_id &tuple) const
 {
-  auto res = isl_union_pw_aff_empty_ctx(ctx.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).bind(tuple);
 }
 
-isl::union_pw_aff union_pw_aff::empty_space(isl::space space)
+isl::union_set union_pw_aff::bind(isl::id id) const
 {
-  auto res = isl_union_pw_aff_empty_space(space.release());
+  auto res = isl_union_pw_aff_bind_id(copy(), id.release());
   return manage(res);
 }
 
-isl::pw_aff union_pw_aff::extract_pw_aff(isl::space space) const
+isl::union_set union_pw_aff::bind(const std::string &id) const
 {
-  auto res = isl_union_pw_aff_extract_pw_aff(get(), space.release());
+  return this->bind(isl::id(ctx(), id));
+}
+
+isl::union_pw_aff union_pw_aff::coalesce() const
+{
+  auto res = isl_union_pw_aff_coalesce(copy());
   return manage(res);
 }
 
-int union_pw_aff::find_dim_by_name(isl::dim type, const std::string &name) const
+class size union_pw_aff::dim(isl::dim type) const
 {
-  auto res = isl_union_pw_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return res;
+  return isl::multi_union_pw_aff(*this).dim(type);
 }
 
-isl::union_pw_aff union_pw_aff::floor() const
+isl::union_set union_pw_aff::domain() const
 {
-  auto res = isl_union_pw_aff_floor(copy());
+  auto res = isl_union_pw_aff_domain(copy());
   return manage(res);
 }
 
-stat union_pw_aff::foreach_pw_aff(const std::function<stat(pw_aff)> &fn) const
+isl::union_pw_aff union_pw_aff::empty(isl::space space)
 {
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_union_pw_aff_foreach_pw_aff(get(), fn_lambda, &fn_data);
+  auto res = isl_union_pw_aff_empty(space.release());
   return manage(res);
 }
 
-isl::pw_aff_list union_pw_aff::get_pw_aff_list() const
+isl::pw_multi_aff union_pw_aff::extract_pw_multi_aff(const isl::space &space) const
 {
-  auto res = isl_union_pw_aff_get_pw_aff_list(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).extract_pw_multi_aff(space);
 }
 
-isl::space union_pw_aff::get_space() const
+isl::multi_union_pw_aff union_pw_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_union_pw_aff_get_space(get());
+  return isl::multi_union_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::union_pw_multi_aff union_pw_aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+stat union_pw_aff::foreach_pw_aff(const std::function<stat(isl::pw_aff)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(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);
+    auto ret = (data->func)(manage(arg_0));
+    return ret.release();
+  };
+  auto res = isl_union_pw_aff_foreach_pw_aff(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
 isl::union_pw_aff union_pw_aff::gist(isl::union_set context) const
 {
   auto res = isl_union_pw_aff_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::union_pw_aff union_pw_aff::gist_params(isl::set context) const
+boolean union_pw_aff::has_range_tuple_id() const
 {
-  auto res = isl_union_pw_aff_gist_params(copy(), context.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).has_range_tuple_id();
 }
 
 isl::union_pw_aff union_pw_aff::intersect_domain(isl::space space) const
 {
   auto res = isl_union_pw_aff_intersect_domain_space(copy(), space.release());
   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);
 }
 
-boolean union_pw_aff::involves_nan() const
+boolean union_pw_aff::involves_locals() const
 {
-  auto res = isl_union_pw_aff_involves_nan(get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).involves_locals();
 }
 
-isl::val union_pw_aff::max_val() const
+boolean union_pw_aff::involves_nan() const
 {
-  auto res = isl_union_pw_aff_max_val(copy());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).involves_nan();
 }
 
-isl::val union_pw_aff::min_val() const
+boolean union_pw_aff::isa_pw_multi_aff() const
 {
-  auto res = isl_union_pw_aff_min_val(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).isa_pw_multi_aff();
 }
 
-isl::union_pw_aff union_pw_aff::mod_val(isl::val f) const
+isl::union_pw_aff_list union_pw_aff::list() const
 {
-  auto res = isl_union_pw_aff_mod_val(copy(), f.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).list();
 }
 
-isl_size union_pw_aff::n_pw_aff() const
+isl::multi_union_pw_aff union_pw_aff::neg() const
 {
-  auto res = isl_union_pw_aff_n_pw_aff(get());
-  return res;
+  return isl::multi_union_pw_aff(*this).neg();
 }
 
-isl::union_pw_aff union_pw_aff::neg() const
+boolean union_pw_aff::plain_is_empty() const
 {
-  auto res = isl_union_pw_aff_neg(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).plain_is_empty();
 }
 
-isl::union_pw_aff union_pw_aff::param_on_domain_id(isl::union_set domain, isl::id id)
+boolean union_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
 {
-  auto res = isl_union_pw_aff_param_on_domain_id(domain.release(), id.release());
-  return manage(res);
+  return isl::multi_union_pw_aff(*this).plain_is_equal(multi2);
 }
 
-boolean union_pw_aff::plain_is_equal(const isl::union_pw_aff &upa2) const
+isl::union_pw_multi_aff union_pw_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_union_pw_aff_plain_is_equal(get(), upa2.get());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
 }
 
 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_aff union_pw_aff::pw_aff_on_domain(isl::union_set domain, isl::pw_aff pa)
+isl::pw_multi_aff_list union_pw_aff::pw_multi_aff_list() const
 {
-  auto res = isl_union_pw_aff_pw_aff_on_domain(domain.release(), pa.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).pw_multi_aff_list();
 }
 
-isl::union_pw_aff union_pw_aff::reset_user() const
+isl::union_pw_multi_aff union_pw_aff::range_factor_domain() const
 {
-  auto res = isl_union_pw_aff_reset_user(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).range_factor_domain();
 }
 
-isl::union_pw_aff union_pw_aff::scale_down_val(isl::val v) const
+isl::union_pw_multi_aff union_pw_aff::range_factor_range() const
 {
-  auto res = isl_union_pw_aff_scale_down_val(copy(), v.release());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).range_factor_range();
+}
+
+isl::multi_union_pw_aff union_pw_aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::multi_union_pw_aff(*this).range_product(multi2);
+}
+
+isl::union_pw_multi_aff union_pw_aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::id union_pw_aff::range_tuple_id() const
+{
+  return isl::multi_union_pw_aff(*this).range_tuple_id();
+}
+
+isl::multi_union_pw_aff union_pw_aff::reset_range_tuple_id() const
+{
+  return isl::multi_union_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::multi_union_pw_aff union_pw_aff::reset_tuple_id(isl::dim type) const
+{
+  return isl::multi_union_pw_aff(*this).reset_tuple_id(type);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale(const isl::multi_val &mv) const
+{
+  return isl::multi_union_pw_aff(*this).scale(mv);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale(const isl::val &v) const
+{
+  return isl::multi_union_pw_aff(*this).scale(v);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale(long v) const
+{
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale_down(const isl::multi_val &mv) const
+{
+  return isl::multi_union_pw_aff(*this).scale_down(mv);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale_down(const isl::val &v) const
+{
+  return isl::multi_union_pw_aff(*this).scale_down(v);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::val(ctx(), v));
 }
 
-isl::union_pw_aff union_pw_aff::scale_val(isl::val v) const
+isl::multi_union_pw_aff union_pw_aff::set_at(int pos, const isl::union_pw_aff &el) const
 {
-  auto res = isl_union_pw_aff_scale_val(copy(), v.release());
+  return isl::multi_union_pw_aff(*this).set_at(pos, el);
+}
+
+isl::multi_union_pw_aff union_pw_aff::set_range_tuple(const isl::id &id) const
+{
+  return isl::multi_union_pw_aff(*this).set_range_tuple(id);
+}
+
+isl::multi_union_pw_aff union_pw_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::multi_union_pw_aff union_pw_aff::set_union_pw_aff(int pos, const isl::union_pw_aff &el) const
+{
+  return isl::multi_union_pw_aff(*this).set_union_pw_aff(pos, el);
+}
+
+class size union_pw_aff::size() const
+{
+  return isl::multi_union_pw_aff(*this).size();
+}
+
+isl::space union_pw_aff::space() const
+{
+  auto res = isl_union_pw_aff_get_space(get());
   return manage(res);
 }
 
+isl::space union_pw_aff::get_space() const
+{
+  return space();
+}
+
+isl::multi_union_pw_aff union_pw_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  return isl::multi_union_pw_aff(*this).sub(multi2);
+}
+
 isl::union_pw_aff union_pw_aff::sub(isl::union_pw_aff upa2) const
 {
   auto res = isl_union_pw_aff_sub(copy(), upa2.release());
   return manage(res);
 }
 
+isl::union_pw_multi_aff union_pw_aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  return isl::union_pw_multi_aff(*this).sub(upma2);
+}
+
+isl::union_pw_aff union_pw_aff::sub(const isl::aff &upa2) const
+{
+  return this->sub(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_aff union_pw_aff::sub(const isl::pw_aff &upa2) const
+{
+  return this->sub(isl::union_pw_aff(upa2));
+}
+
 isl::union_pw_aff union_pw_aff::subtract_domain(isl::space space) const
 {
   auto res = isl_union_pw_aff_subtract_domain_space(copy(), space.release());
   return manage(res);
 }
 
 isl::union_pw_aff union_pw_aff::subtract_domain(isl::union_set uset) const
 {
   auto res = isl_union_pw_aff_subtract_domain_union_set(copy(), uset.release());
   return manage(res);
 }
 
+isl::union_pw_aff_list union_pw_aff::to_list() const
+{
+  auto res = isl_union_pw_aff_to_list(copy());
+  return manage(res);
+}
+
+isl::multi_union_pw_aff union_pw_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  return isl::multi_union_pw_aff(*this).union_add(mupa2);
+}
+
 isl::union_pw_aff union_pw_aff::union_add(isl::union_pw_aff upa2) const
 {
   auto res = isl_union_pw_aff_union_add(copy(), upa2.release());
   return manage(res);
 }
 
-isl::union_set union_pw_aff::zero_union_set() const
+isl::union_pw_multi_aff union_pw_aff::union_add(const isl::union_pw_multi_aff &upma2) const
 {
-  auto res = isl_union_pw_aff_zero_union_set(copy());
-  return manage(res);
+  return isl::union_pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::union_pw_aff union_pw_aff::union_add(const isl::aff &upa2) const
+{
+  return this->union_add(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_aff union_pw_aff::union_add(const isl::pw_aff &upa2) const
+{
+  return this->union_add(isl::union_pw_aff(upa2));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_pw_aff &obj)
+{
+  char *str = isl_union_pw_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::union_pw_aff_list
 union_pw_aff_list manage(__isl_take isl_union_pw_aff_list *ptr) {
   return union_pw_aff_list(ptr);
 }
 union_pw_aff_list manage_copy(__isl_keep isl_union_pw_aff_list *ptr) {
   ptr = isl_union_pw_aff_list_copy(ptr);
   return union_pw_aff_list(ptr);
 }
 
 union_pw_aff_list::union_pw_aff_list()
     : ptr(nullptr) {}
 
 union_pw_aff_list::union_pw_aff_list(const union_pw_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_pw_aff_list::union_pw_aff_list(__isl_take isl_union_pw_aff_list *ptr)
     : ptr(ptr) {}
 
+union_pw_aff_list::union_pw_aff_list(isl::ctx ctx, int n)
+{
+  auto res = isl_union_pw_aff_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+union_pw_aff_list::union_pw_aff_list(isl::union_pw_aff el)
+{
+  auto res = isl_union_pw_aff_list_from_union_pw_aff(el.release());
+  ptr = res;
+}
+
+union_pw_aff_list::union_pw_aff_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_union_pw_aff_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 union_pw_aff_list &union_pw_aff_list::operator=(union_pw_aff_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 union_pw_aff_list::~union_pw_aff_list() {
   if (ptr)
__isl_give isl_union_pw_aff_list *union_pw_aff_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_pw_aff_list::ctx() const {
   return isl::ctx(isl_union_pw_aff_list_get_ctx(ptr));
 }
 
-void union_pw_aff_list::dump() const {
-  isl_union_pw_aff_list_dump(get());
-}
-
-
 isl::union_pw_aff_list union_pw_aff_list::add(isl::union_pw_aff el) const
 {
   auto res = isl_union_pw_aff_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::union_pw_aff_list union_pw_aff_list::alloc(isl::ctx ctx, int n)
+isl::union_pw_aff union_pw_aff_list::at(int index) const
 {
-  auto res = isl_union_pw_aff_list_alloc(ctx.release(), n);
+  auto res = isl_union_pw_aff_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::union_pw_aff union_pw_aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::union_pw_aff_list union_pw_aff_list::clear() const
 {
   auto res = isl_union_pw_aff_list_clear(copy());
   return manage(res);
 }
 
 isl::union_pw_aff_list union_pw_aff_list::concat(isl::union_pw_aff_list list2) const
 {
   auto res = isl_union_pw_aff_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::union_pw_aff_list union_pw_aff_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_union_pw_aff_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat union_pw_aff_list::foreach(const std::function<stat(union_pw_aff)> &fn) const
+stat union_pw_aff_list::foreach(const std::function<stat(isl::union_pw_aff)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(union_pw_aff)> *func;
-  } fn_data = { &fn };
+    std::function<stat(isl::union_pw_aff)> func;
+  } fn_data = { fn };
   auto fn_lambda = [](isl_union_pw_aff *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_union_pw_aff_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::union_pw_aff_list union_pw_aff_list::from_union_pw_aff(isl::union_pw_aff el)
-{
-  auto res = isl_union_pw_aff_list_from_union_pw_aff(el.release());
-  return manage(res);
-}
-
-isl::union_pw_aff union_pw_aff_list::get_at(int index) const
-{
-  auto res = isl_union_pw_aff_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::union_pw_aff union_pw_aff_list::get_union_pw_aff(int index) const
-{
-  auto res = isl_union_pw_aff_list_get_union_pw_aff(get(), index);
-  return manage(res);
-}
-
 isl::union_pw_aff_list union_pw_aff_list::insert(unsigned int pos, isl::union_pw_aff el) const
 {
   auto res = isl_union_pw_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size union_pw_aff_list::n_union_pw_aff() const
-{
-  auto res = isl_union_pw_aff_list_n_union_pw_aff(get());
-  return res;
-}
-
-isl::union_pw_aff_list union_pw_aff_list::reverse() const
-{
-  auto res = isl_union_pw_aff_list_reverse(copy());
-  return manage(res);
-}
-
-isl::union_pw_aff_list union_pw_aff_list::set_union_pw_aff(int index, isl::union_pw_aff el) const
-{
-  auto res = isl_union_pw_aff_list_set_union_pw_aff(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size union_pw_aff_list::size() const
+class size union_pw_aff_list::size() const
 {
   auto res = isl_union_pw_aff_list_size(get());
-  return res;
+  return manage(res);
 }
 
-isl::union_pw_aff_list union_pw_aff_list::swap(unsigned int pos1, unsigned int pos2) const
+inline std::ostream &operator<<(std::ostream &os, const union_pw_aff_list &obj)
 {
-  auto res = isl_union_pw_aff_list_swap(copy(), pos1, pos2);
-  return manage(res);
+  char *str = isl_union_pw_aff_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::union_pw_multi_aff
 union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr) {
   return union_pw_multi_aff(ptr);
 }
 union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr) {
   ptr = isl_union_pw_multi_aff_copy(ptr);
   return union_pw_multi_aff(ptr);
 }
 
 union_pw_multi_aff::union_pw_multi_aff()
     : ptr(nullptr) {}
 
 union_pw_multi_aff::union_pw_multi_aff(const union_pw_multi_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_pw_multi_aff::union_pw_multi_aff(__isl_take isl_union_pw_multi_aff *ptr)
     : ptr(ptr) {}
 
-union_pw_multi_aff::union_pw_multi_aff(isl::aff aff)
-{
-  auto res = isl_union_pw_multi_aff_from_aff(aff.release());
-  ptr = res;
-}
 union_pw_multi_aff::union_pw_multi_aff(isl::union_set uset)
 {
   auto res = isl_union_pw_multi_aff_from_domain(uset.release());
   ptr = res;
 }
+
 union_pw_multi_aff::union_pw_multi_aff(isl::multi_aff ma)
 {
   auto res = isl_union_pw_multi_aff_from_multi_aff(ma.release());
   ptr = res;
 }
-union_pw_multi_aff::union_pw_multi_aff(isl::multi_union_pw_aff mupa)
-{
-  auto res = isl_union_pw_multi_aff_from_multi_union_pw_aff(mupa.release());
-  ptr = res;
-}
+
 union_pw_multi_aff::union_pw_multi_aff(isl::pw_multi_aff pma)
 {
   auto res = isl_union_pw_multi_aff_from_pw_multi_aff(pma.release());
   ptr = res;
 }
+
 union_pw_multi_aff::union_pw_multi_aff(isl::union_map umap)
 {
   auto res = isl_union_pw_multi_aff_from_union_map(umap.release());
   ptr = res;
 }
+
 union_pw_multi_aff::union_pw_multi_aff(isl::union_pw_aff upa)
 {
   auto res = isl_union_pw_multi_aff_from_union_pw_aff(upa.release());
   ptr = res;
 }
+
 union_pw_multi_aff::union_pw_multi_aff(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_union_pw_multi_aff_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 union_pw_multi_aff &union_pw_multi_aff::operator=(union_pw_multi_aff obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_union_pw_multi_aff *union_pw_multi_aff::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_multi_aff::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_pw_multi_aff::ctx() const {
   return isl::ctx(isl_union_pw_multi_aff_get_ctx(ptr));
 }
 
-void union_pw_multi_aff::dump() const {
-  isl_union_pw_multi_aff_dump(get());
-}
-
-
 isl::union_pw_multi_aff union_pw_multi_aff::add(isl::union_pw_multi_aff upma2) const
 {
   auto res = isl_union_pw_multi_aff_add(copy(), upma2.release());
   return manage(res);
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::add_pw_multi_aff(isl::pw_multi_aff pma) const
 {
   auto res = isl_union_pw_multi_aff_add_pw_multi_aff(copy(), pma.release());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::align_params(isl::space model) const
+isl::union_pw_multi_aff union_pw_multi_aff::apply(isl::union_pw_multi_aff upma2) const
 {
-  auto res = isl_union_pw_multi_aff_align_params(copy(), model.release());
+  auto res = isl_union_pw_multi_aff_apply_union_pw_multi_aff(copy(), upma2.release());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::apply(isl::union_pw_multi_aff upma2) const
+isl::multi_union_pw_aff union_pw_multi_aff::as_multi_union_pw_aff() const
 {
-  auto res = isl_union_pw_multi_aff_apply_union_pw_multi_aff(copy(), upma2.release());
+  auto res = isl_union_pw_multi_aff_as_multi_union_pw_aff(copy());
   return manage(res);
 }
 
 isl::pw_multi_aff union_pw_multi_aff::as_pw_multi_aff() const
 {
   auto res = isl_union_pw_multi_aff_as_pw_multi_aff(copy());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::coalesce() const
+isl::union_map union_pw_multi_aff::as_union_map() const
 {
-  auto res = isl_union_pw_multi_aff_coalesce(copy());
+  auto res = isl_union_pw_multi_aff_as_union_map(copy());
   return manage(res);
 }
 
-isl_size union_pw_multi_aff::dim(isl::dim type) const
+isl::union_pw_multi_aff union_pw_multi_aff::coalesce() const
 {
-  auto res = isl_union_pw_multi_aff_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  auto res = isl_union_pw_multi_aff_coalesce(copy());
+  return manage(res);
 }
 
 isl::union_set union_pw_multi_aff::domain() const
 {
   auto res = isl_union_pw_multi_aff_domain(copy());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_pw_multi_aff_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
 isl::union_pw_multi_aff union_pw_multi_aff::empty(isl::space space)
 {
   auto res = isl_union_pw_multi_aff_empty(space.release());
   return manage(res);
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::empty(isl::ctx ctx)
 {
   auto res = isl_union_pw_multi_aff_empty_ctx(ctx.release());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::empty_space(isl::space space)
-{
-  auto res = isl_union_pw_multi_aff_empty_space(space.release());
-  return manage(res);
-}
-
 isl::pw_multi_aff union_pw_multi_aff::extract_pw_multi_aff(isl::space space) const
 {
   auto res = isl_union_pw_multi_aff_extract_pw_multi_aff(get(), space.release());
   return manage(res);
 }
 
-int union_pw_multi_aff::find_dim_by_name(isl::dim type, const std::string &name) const
-{
-  auto res = isl_union_pw_multi_aff_find_dim_by_name(get(), static_cast<enum isl_dim_type>(type), name.c_str());
-  return 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);
 }
 
-stat union_pw_multi_aff::foreach_pw_multi_aff(const std::function<stat(pw_multi_aff)> &fn) const
-{
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_union_pw_multi_aff_foreach_pw_multi_aff(get(), fn_lambda, &fn_data);
-  return manage(res);
-}
-
-isl::union_pw_multi_aff union_pw_multi_aff::from_union_set(isl::union_set uset)
-{
-  auto res = isl_union_pw_multi_aff_from_union_set(uset.release());
-  return manage(res);
-}
-
-isl::pw_multi_aff_list union_pw_multi_aff::get_pw_multi_aff_list() const
-{
-  auto res = isl_union_pw_multi_aff_get_pw_multi_aff_list(get());
-  return manage(res);
-}
-
-isl::space union_pw_multi_aff::get_space() const
-{
-  auto res = isl_union_pw_multi_aff_get_space(get());
-  return manage(res);
-}
-
-isl::union_pw_aff union_pw_multi_aff::get_union_pw_aff(int pos) const
-{
-  auto res = isl_union_pw_multi_aff_get_union_pw_aff(get(), pos);
-  return manage(res);
-}
-
 isl::union_pw_multi_aff union_pw_multi_aff::gist(isl::union_set context) const
 {
   auto res = isl_union_pw_multi_aff_gist(copy(), context.release());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::gist_params(isl::set context) const
-{
-  auto res = isl_union_pw_multi_aff_gist_params(copy(), context.release());
-  return manage(res);
-}
-
 isl::union_pw_multi_aff union_pw_multi_aff::intersect_domain(isl::space space) const
 {
   auto res = isl_union_pw_multi_aff_intersect_domain_space(copy(), space.release());
   return manage(res);
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::intersect_domain(isl::union_set uset) const
 {

 }
 
 boolean union_pw_multi_aff::involves_locals() const
 {
   auto res = isl_union_pw_multi_aff_involves_locals(get());
   return manage(res);
 }
 
-boolean union_pw_multi_aff::involves_nan() const
-{
-  auto res = isl_union_pw_multi_aff_involves_nan(get());
-  return manage(res);
-}
-
 boolean union_pw_multi_aff::isa_pw_multi_aff() const
 {
   auto res = isl_union_pw_multi_aff_isa_pw_multi_aff(get());
   return manage(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);
-}
-
-isl_size 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);
-}
-
 boolean union_pw_multi_aff::plain_is_empty() const
 {
   auto res = isl_union_pw_multi_aff_plain_is_empty(get());
   return manage(res);
 }
 
-boolean union_pw_multi_aff::plain_is_equal(const isl::union_pw_multi_aff &upma2) const
-{
-  auto res = isl_union_pw_multi_aff_plain_is_equal(get(), upma2.get());
-  return manage(res);
-}
-
 isl::union_pw_multi_aff union_pw_multi_aff::preimage_domain_wrapped_domain(isl::union_pw_multi_aff upma2) const
 {
   auto res = isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(copy(), upma2.release());
   return manage(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);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::range_factor_domain() const
+isl::pw_multi_aff_list union_pw_multi_aff::pw_multi_aff_list() const
 {
-  auto res = isl_union_pw_multi_aff_range_factor_domain(copy());
+  auto res = isl_union_pw_multi_aff_get_pw_multi_aff_list(get());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::range_factor_range() const
+isl::pw_multi_aff_list union_pw_multi_aff::get_pw_multi_aff_list() const
 {
-  auto res = isl_union_pw_multi_aff_range_factor_range(copy());
-  return manage(res);
+  return pw_multi_aff_list();
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::range_product(isl::union_pw_multi_aff upma2) const
+isl::union_pw_multi_aff union_pw_multi_aff::range_factor_domain() const
 {
-  auto res = isl_union_pw_multi_aff_range_product(copy(), upma2.release());
+  auto res = isl_union_pw_multi_aff_range_factor_domain(copy());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::reset_user() const
+isl::union_pw_multi_aff union_pw_multi_aff::range_factor_range() const
 {
-  auto res = isl_union_pw_multi_aff_reset_user(copy());
+  auto res = isl_union_pw_multi_aff_range_factor_range(copy());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::scale_down_val(isl::val val) const
+isl::union_pw_multi_aff union_pw_multi_aff::range_product(isl::union_pw_multi_aff upma2) const
 {
-  auto res = isl_union_pw_multi_aff_scale_down_val(copy(), val.release());
+  auto res = isl_union_pw_multi_aff_range_product(copy(), upma2.release());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::scale_multi_val(isl::multi_val mv) const
+isl::space union_pw_multi_aff::space() const
 {
-  auto res = isl_union_pw_multi_aff_scale_multi_val(copy(), mv.release());
+  auto res = isl_union_pw_multi_aff_get_space(get());
   return manage(res);
 }
 
-isl::union_pw_multi_aff union_pw_multi_aff::scale_val(isl::val val) const
+isl::space union_pw_multi_aff::get_space() const
 {
-  auto res = isl_union_pw_multi_aff_scale_val(copy(), val.release());
-  return manage(res);
+  return space();
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::sub(isl::union_pw_multi_aff upma2) const
 {
   auto res = isl_union_pw_multi_aff_sub(copy(), upma2.release());
   return manage(res);
 }
 

 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::union_add(isl::union_pw_multi_aff upma2) const
 {
   auto res = isl_union_pw_multi_aff_union_add(copy(), upma2.release());
   return manage(res);
 }
 
-// implementations for isl::union_pw_multi_aff_list
-union_pw_multi_aff_list manage(__isl_take isl_union_pw_multi_aff_list *ptr) {
-  return union_pw_multi_aff_list(ptr);
-}
-union_pw_multi_aff_list manage_copy(__isl_keep isl_union_pw_multi_aff_list *ptr) {
-  ptr = isl_union_pw_multi_aff_list_copy(ptr);
-  return union_pw_multi_aff_list(ptr);
-}
-
-union_pw_multi_aff_list::union_pw_multi_aff_list()
-    : ptr(nullptr) {}
-
-union_pw_multi_aff_list::union_pw_multi_aff_list(const union_pw_multi_aff_list &obj)
-    : ptr(nullptr)
-{
-  ptr = obj.copy();
-}
-
-
-union_pw_multi_aff_list::union_pw_multi_aff_list(__isl_take isl_union_pw_multi_aff_list *ptr)
-    : ptr(ptr) {}
-
-
-union_pw_multi_aff_list &union_pw_multi_aff_list::operator=(union_pw_multi_aff_list obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
-}
-
-union_pw_multi_aff_list::~union_pw_multi_aff_list() {
-  if (ptr)
-    isl_union_pw_multi_aff_list_free(ptr);
-}
-
-__isl_give isl_union_pw_multi_aff_list *union_pw_multi_aff_list::copy() const & {
-  return isl_union_pw_multi_aff_list_copy(ptr);
-}
-
-__isl_keep isl_union_pw_multi_aff_list *union_pw_multi_aff_list::get() const {
-  return ptr;
-}
-
-__isl_give isl_union_pw_multi_aff_list *union_pw_multi_aff_list::release() {
-  isl_union_pw_multi_aff_list *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
-}
-
-bool union_pw_multi_aff_list::is_null() const {
-  return ptr == nullptr;
-}
-
-
-isl::ctx union_pw_multi_aff_list::ctx() const {
-  return isl::ctx(isl_union_pw_multi_aff_list_get_ctx(ptr));
-}
-
-void union_pw_multi_aff_list::dump() const {
-  isl_union_pw_multi_aff_list_dump(get());
-}
-
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::add(isl::union_pw_multi_aff el) const
+inline std::ostream &operator<<(std::ostream &os, const union_pw_multi_aff &obj)
 {
-  auto res = isl_union_pw_multi_aff_list_add(copy(), el.release());
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::alloc(isl::ctx ctx, int n)
-{
-  auto res = isl_union_pw_multi_aff_list_alloc(ctx.release(), n);
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::clear() const
-{
-  auto res = isl_union_pw_multi_aff_list_clear(copy());
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::concat(isl::union_pw_multi_aff_list list2) const
-{
-  auto res = isl_union_pw_multi_aff_list_concat(copy(), list2.release());
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::drop(unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_pw_multi_aff_list_drop(copy(), first, n);
-  return manage(res);
-}
-
-stat union_pw_multi_aff_list::foreach(const std::function<stat(union_pw_multi_aff)> &fn) const
-{
-  struct fn_data {
-    const std::function<stat(union_pw_multi_aff)> *func;
-  } fn_data = { &fn };
-  auto fn_lambda = [](isl_union_pw_multi_aff *arg_0, void *arg_1) -> isl_stat {
-    auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_union_pw_multi_aff_list_foreach(get(), fn_lambda, &fn_data);
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::from_union_pw_multi_aff(isl::union_pw_multi_aff el)
-{
-  auto res = isl_union_pw_multi_aff_list_from_union_pw_multi_aff(el.release());
-  return manage(res);
-}
-
-isl::union_pw_multi_aff union_pw_multi_aff_list::get_at(int index) const
-{
-  auto res = isl_union_pw_multi_aff_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::union_pw_multi_aff union_pw_multi_aff_list::get_union_pw_multi_aff(int index) const
-{
-  auto res = isl_union_pw_multi_aff_list_get_union_pw_multi_aff(get(), index);
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::insert(unsigned int pos, isl::union_pw_multi_aff el) const
-{
-  auto res = isl_union_pw_multi_aff_list_insert(copy(), pos, el.release());
-  return manage(res);
-}
-
-isl_size union_pw_multi_aff_list::n_union_pw_multi_aff() const
-{
-  auto res = isl_union_pw_multi_aff_list_n_union_pw_multi_aff(get());
-  return res;
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::reverse() const
-{
-  auto res = isl_union_pw_multi_aff_list_reverse(copy());
-  return manage(res);
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::set_union_pw_multi_aff(int index, isl::union_pw_multi_aff el) const
-{
-  auto res = isl_union_pw_multi_aff_list_set_union_pw_multi_aff(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size union_pw_multi_aff_list::size() const
-{
-  auto res = isl_union_pw_multi_aff_list_size(get());
-  return res;
-}
-
-isl::union_pw_multi_aff_list union_pw_multi_aff_list::swap(unsigned int pos1, unsigned int pos2) const
-{
-  auto res = isl_union_pw_multi_aff_list_swap(copy(), pos1, pos2);
-  return manage(res);
-}
-
-// implementations for isl::union_pw_qpolynomial
-union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr) {
-  return union_pw_qpolynomial(ptr);
-}
-union_pw_qpolynomial manage_copy(__isl_keep isl_union_pw_qpolynomial *ptr) {
-  ptr = isl_union_pw_qpolynomial_copy(ptr);
-  return union_pw_qpolynomial(ptr);
-}
-
-union_pw_qpolynomial::union_pw_qpolynomial()
-    : ptr(nullptr) {}
-
-union_pw_qpolynomial::union_pw_qpolynomial(const union_pw_qpolynomial &obj)
-    : ptr(nullptr)
-{
-  ptr = obj.copy();
-}
-
-
-union_pw_qpolynomial::union_pw_qpolynomial(__isl_take isl_union_pw_qpolynomial *ptr)
-    : ptr(ptr) {}
-
-union_pw_qpolynomial::union_pw_qpolynomial(isl::ctx ctx, const std::string &str)
-{
-  auto res = isl_union_pw_qpolynomial_read_from_str(ctx.release(), str.c_str());
-  ptr = res;
-}
-
-union_pw_qpolynomial &union_pw_qpolynomial::operator=(union_pw_qpolynomial obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
-}
-
-union_pw_qpolynomial::~union_pw_qpolynomial() {
-  if (ptr)
-    isl_union_pw_qpolynomial_free(ptr);
-}
-
-__isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial::copy() const & {
-  return isl_union_pw_qpolynomial_copy(ptr);
-}
-
-__isl_keep isl_union_pw_qpolynomial *union_pw_qpolynomial::get() const {
-  return ptr;
-}
-
-__isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial::release() {
-  isl_union_pw_qpolynomial *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
-}
-
-bool union_pw_qpolynomial::is_null() const {
-  return ptr == nullptr;
-}
-
-
-isl::ctx union_pw_qpolynomial::ctx() const {
-  return isl::ctx(isl_union_pw_qpolynomial_get_ctx(ptr));
-}
-
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::add(isl::union_pw_qpolynomial upwqp2) const
-{
-  auto res = isl_union_pw_qpolynomial_add(copy(), upwqp2.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::add_pw_qpolynomial(isl::pw_qpolynomial pwqp) const
-{
-  auto res = isl_union_pw_qpolynomial_add_pw_qpolynomial(copy(), pwqp.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::align_params(isl::space model) const
-{
-  auto res = isl_union_pw_qpolynomial_align_params(copy(), model.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::coalesce() const
-{
-  auto res = isl_union_pw_qpolynomial_coalesce(copy());
-  return manage(res);
-}
-
-isl_size union_pw_qpolynomial::dim(isl::dim type) const
-{
-  auto res = isl_union_pw_qpolynomial_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
-}
-
-isl::union_set union_pw_qpolynomial::domain() const
-{
-  auto res = isl_union_pw_qpolynomial_domain(copy());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::drop_dims(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_pw_qpolynomial_drop_dims(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
-isl::val union_pw_qpolynomial::eval(isl::point pnt) const
-{
-  auto res = isl_union_pw_qpolynomial_eval(copy(), pnt.release());
-  return manage(res);
-}
-
-isl::pw_qpolynomial union_pw_qpolynomial::extract_pw_qpolynomial(isl::space space) const
-{
-  auto res = isl_union_pw_qpolynomial_extract_pw_qpolynomial(get(), space.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;
-}
-
-stat union_pw_qpolynomial::foreach_pw_qpolynomial(const std::function<stat(pw_qpolynomial)> &fn) const
-{
-  struct fn_data {
-    const std::function<stat(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)(manage(arg_0));
-    return ret.release();
-  };
-  auto res = isl_union_pw_qpolynomial_foreach_pw_qpolynomial(get(), fn_lambda, &fn_data);
-  return manage(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::pw_qpolynomial_list union_pw_qpolynomial::get_pw_qpolynomial_list() const
-{
-  auto res = isl_union_pw_qpolynomial_get_pw_qpolynomial_list(get());
-  return manage(res);
-}
-
-isl::space union_pw_qpolynomial::get_space() const
-{
-  auto res = isl_union_pw_qpolynomial_get_space(get());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::gist(isl::union_set context) const
-{
-  auto res = isl_union_pw_qpolynomial_gist(copy(), context.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::gist_params(isl::set context) const
-{
-  auto res = isl_union_pw_qpolynomial_gist_params(copy(), context.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::intersect_domain(isl::union_set uset) const
-{
-  auto res = isl_union_pw_qpolynomial_intersect_domain(copy(), uset.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::intersect_domain_space(isl::space space) const
-{
-  auto res = isl_union_pw_qpolynomial_intersect_domain_space(copy(), space.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::intersect_domain_union_set(isl::union_set uset) const
-{
-  auto res = isl_union_pw_qpolynomial_intersect_domain_union_set(copy(), uset.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::intersect_domain_wrapped_domain(isl::union_set uset) const
-{
-  auto res = isl_union_pw_qpolynomial_intersect_domain_wrapped_domain(copy(), uset.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::intersect_domain_wrapped_range(isl::union_set uset) const
-{
-  auto res = isl_union_pw_qpolynomial_intersect_domain_wrapped_range(copy(), uset.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);
-}
-
-boolean union_pw_qpolynomial::involves_nan() const
-{
-  auto res = isl_union_pw_qpolynomial_involves_nan(get());
-  return manage(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);
-}
-
-isl_size 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);
-}
-
-boolean union_pw_qpolynomial::plain_is_equal(const isl::union_pw_qpolynomial &upwqp2) const
-{
-  auto res = isl_union_pw_qpolynomial_plain_is_equal(get(), upwqp2.get());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::reset_user() const
-{
-  auto res = isl_union_pw_qpolynomial_reset_user(copy());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::scale_down_val(isl::val v) const
-{
-  auto res = isl_union_pw_qpolynomial_scale_down_val(copy(), v.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::scale_val(isl::val v) const
-{
-  auto res = isl_union_pw_qpolynomial_scale_val(copy(), v.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::sub(isl::union_pw_qpolynomial upwqp2) const
-{
-  auto res = isl_union_pw_qpolynomial_sub(copy(), upwqp2.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::subtract_domain(isl::union_set uset) const
-{
-  auto res = isl_union_pw_qpolynomial_subtract_domain(copy(), uset.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::subtract_domain_space(isl::space space) const
-{
-  auto res = isl_union_pw_qpolynomial_subtract_domain_space(copy(), space.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::subtract_domain_union_set(isl::union_set uset) const
-{
-  auto res = isl_union_pw_qpolynomial_subtract_domain_union_set(copy(), uset.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::to_polynomial(int sign) const
-{
-  auto res = isl_union_pw_qpolynomial_to_polynomial(copy(), sign);
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::zero(isl::space space)
-{
-  auto res = isl_union_pw_qpolynomial_zero(space.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::zero_ctx(isl::ctx ctx)
-{
-  auto res = isl_union_pw_qpolynomial_zero_ctx(ctx.release());
-  return manage(res);
-}
-
-isl::union_pw_qpolynomial union_pw_qpolynomial::zero_space(isl::space space)
-{
-  auto res = isl_union_pw_qpolynomial_zero_space(space.release());
-  return manage(res);
+  char *str = isl_union_pw_multi_aff_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::union_set
 union_set manage(__isl_take isl_union_set *ptr) {
   return union_set(ptr);
 }
 union_set manage_copy(__isl_keep isl_union_set *ptr) {
   ptr = isl_union_set_copy(ptr);
   return union_set(ptr);
 }
 
 union_set::union_set()
     : ptr(nullptr) {}
 
 union_set::union_set(const union_set &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_set::union_set(__isl_take isl_union_set *ptr)
     : ptr(ptr) {}
 
 union_set::union_set(isl::basic_set bset)
 {
   auto res = isl_union_set_from_basic_set(bset.release());
   ptr = res;
 }
+
 union_set::union_set(isl::point pnt)
 {
   auto res = isl_union_set_from_point(pnt.release());
   ptr = res;
 }
+
 union_set::union_set(isl::set set)
 {
   auto res = isl_union_set_from_set(set.release());
   ptr = res;
 }
+
 union_set::union_set(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_union_set_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 union_set &union_set::operator=(union_set obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_union_set *union_set::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_set::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_set::ctx() const {
   return isl::ctx(isl_union_set_get_ctx(ptr));
 }
 
-void union_set::dump() const {
-  isl_union_set_dump(get());
-}
-
-
 isl::union_set union_set::affine_hull() const
 {
   auto res = isl_union_set_affine_hull(copy());
   return manage(res);
 }
 
-isl::union_set union_set::align_params(isl::space model) const
-{
-  auto res = isl_union_set_align_params(copy(), model.release());
-  return manage(res);
-}
-
 isl::union_set union_set::apply(isl::union_map umap) const
 {
   auto res = isl_union_set_apply(copy(), umap.release());
   return manage(res);
 }
 
-isl::union_set union_set::coalesce() const
+isl::set union_set::as_set() const
 {
-  auto res = isl_union_set_coalesce(copy());
+  auto res = isl_union_set_as_set(copy());
   return manage(res);
 }
 
-isl::union_set union_set::coefficients() const
+isl::union_set union_set::coalesce() const
 {
-  auto res = isl_union_set_coefficients(copy());
+  auto res = isl_union_set_coalesce(copy());
   return manage(res);
 }
 
-isl::schedule union_set::compute_schedule(isl::union_map validity, isl::union_map proximity) const
+isl::union_set union_set::compute_divs() const
 {
-  auto res = isl_union_set_compute_schedule(copy(), validity.release(), proximity.release());
+  auto res = isl_union_set_compute_divs(copy());
   return manage(res);
 }
 
 boolean union_set::contains(const isl::space &space) const
 {
   auto res = isl_union_set_contains(get(), space.get());
   return manage(res);
 }
 
 isl::union_set union_set::detect_equalities() const
 {
   auto res = isl_union_set_detect_equalities(copy());
   return manage(res);
 }
 
-isl_size union_set::dim(isl::dim type) const
+isl::union_set union_set::empty(isl::ctx ctx)
 {
-  auto res = isl_union_set_dim(get(), static_cast<enum isl_dim_type>(type));
-  return res;
+  auto res = isl_union_set_empty_ctx(ctx.release());
+  return manage(res);
 }
 
-isl::union_set union_set::empty(isl::ctx ctx)
+boolean union_set::every_set(const std::function<boolean(isl::set)> &test) const
 {
-  auto res = isl_union_set_empty_ctx(ctx.release());
+  struct test_data {
+    std::function<boolean(isl::set)> func;
+  } test_data = { test };
+  auto test_lambda = [](isl_set *arg_0, void *arg_1) -> isl_bool {
+    auto *data = static_cast<struct test_data *>(arg_1);
+    auto ret = (data->func)(manage_copy(arg_0));
+    return ret.release();
+  };
+  auto res = isl_union_set_every_set(get(), test_lambda, &test_data);
   return manage(res);
 }
 
 isl::set union_set::extract_set(isl::space space) const
 {
   auto res = isl_union_set_extract_set(get(), space.release());
   return manage(res);
 }
 
-stat union_set::foreach_point(const std::function<stat(point)> &fn) const
+stat union_set::foreach_point(const std::function<stat(isl::point)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(point)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_union_set_foreach_point(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-stat union_set::foreach_set(const std::function<stat(set)> &fn) const
+stat union_set::foreach_set(const std::function<stat(isl::set)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(set)> *func;
-  } fn_data = { &fn };
+    std::function<stat(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)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_union_set_foreach_set(get(), fn_lambda, &fn_data);
   return manage(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);
-}
-
-uint32_t union_set::get_hash() const
-{
-  auto res = isl_union_set_get_hash(get());
-  return res;
-}
-
-isl::set_list union_set::get_set_list() const
-{
-  auto res = isl_union_set_get_set_list(get());
-  return manage(res);
-}
-
-isl::space union_set::get_space() const
-{
-  auto res = isl_union_set_get_space(get());
-  return manage(res);
-}
-
 isl::union_set union_set::gist(isl::union_set context) const
 {
   auto res = isl_union_set_gist(copy(), context.release());
   return manage(res);
 }
 
 isl::union_set union_set::gist_params(isl::set set) const
 {

 }
 
 boolean union_set::is_equal(const isl::union_set &uset2) const
 {
   auto res = isl_union_set_is_equal(get(), uset2.get());
   return manage(res);
 }
 
-boolean union_set::is_params() const
-{
-  auto res = isl_union_set_is_params(get());
-  return manage(res);
-}
-
 boolean union_set::is_strict_subset(const isl::union_set &uset2) const
 {
   auto res = isl_union_set_is_strict_subset(get(), uset2.get());
   return manage(res);
 }
 
 boolean union_set::is_subset(const isl::union_set &uset2) const
 {
   auto res = isl_union_set_is_subset(get(), uset2.get());
   return manage(res);
 }
 
 boolean union_set::isa_set() const
 {
   auto res = isl_union_set_isa_set(get());
   return manage(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::union_map union_set::lex_gt_union_set(isl::union_set uset2) const
-{
-  auto res = isl_union_set_lex_gt_union_set(copy(), uset2.release());
-  return manage(res);
-}
-
-isl::union_map union_set::lex_le_union_set(isl::union_set uset2) const
-{
-  auto res = isl_union_set_lex_le_union_set(copy(), uset2.release());
-  return manage(res);
-}
-
-isl::union_map union_set::lex_lt_union_set(isl::union_set uset2) const
-{
-  auto res = isl_union_set_lex_lt_union_set(copy(), uset2.release());
-  return manage(res);
-}
-
 isl::union_set union_set::lexmax() const
 {
   auto res = isl_union_set_lexmax(copy());
   return manage(res);
 }
 
 isl::union_set union_set::lexmin() const
 {
   auto res = isl_union_set_lexmin(copy());
   return manage(res);
 }
 
-isl::multi_val union_set::min_multi_union_pw_aff(const isl::multi_union_pw_aff &obj) const
-{
-  auto res = isl_union_set_min_multi_union_pw_aff(get(), obj.get());
-  return manage(res);
-}
-
-isl_size union_set::n_set() const
-{
-  auto res = isl_union_set_n_set(get());
-  return res;
-}
-
 isl::set union_set::params() const
 {
   auto res = isl_union_set_params(copy());
   return manage(res);
 }
 
 isl::union_set union_set::polyhedral_hull() const
 {

 }
 
 isl::union_set union_set::preimage(isl::union_pw_multi_aff upma) const
 {
   auto res = isl_union_set_preimage_union_pw_multi_aff(copy(), upma.release());
   return manage(res);
 }
 
-isl::union_set union_set::product(isl::union_set uset2) const
-{
-  auto res = isl_union_set_product(copy(), uset2.release());
-  return manage(res);
-}
-
-isl::union_set union_set::project_out(isl::dim type, unsigned int first, unsigned int n) const
-{
-  auto res = isl_union_set_project_out(copy(), static_cast<enum isl_dim_type>(type), first, n);
-  return manage(res);
-}
-
-isl::union_set union_set::project_out_all_params() const
-{
-  auto res = isl_union_set_project_out_all_params(copy());
-  return manage(res);
-}
-
-isl::union_set union_set::remove_divs() const
-{
-  auto res = isl_union_set_remove_divs(copy());
-  return manage(res);
-}
-
-isl::union_set union_set::remove_redundancies() const
+isl::point union_set::sample_point() const
 {
-  auto res = isl_union_set_remove_redundancies(copy());
+  auto res = isl_union_set_sample_point(copy());
   return manage(res);
 }
 
-isl::union_set union_set::reset_user() const
+isl::set_list union_set::set_list() const
 {
-  auto res = isl_union_set_reset_user(copy());
+  auto res = isl_union_set_get_set_list(get());
   return manage(res);
 }
 
-isl::basic_set union_set::sample() const
+isl::set_list union_set::get_set_list() const
 {
-  auto res = isl_union_set_sample(copy());
-  return manage(res);
+  return set_list();
 }
 
-isl::point union_set::sample_point() const
+isl::space union_set::space() const
 {
-  auto res = isl_union_set_sample_point(copy());
+  auto res = isl_union_set_get_space(get());
   return manage(res);
 }
 
-isl::union_set union_set::simple_hull() const
+isl::space union_set::get_space() const
 {
-  auto res = isl_union_set_simple_hull(copy());
-  return manage(res);
+  return space();
 }
 
-isl::union_set union_set::solutions() const
+isl::union_set union_set::subtract(isl::union_set uset2) const
 {
-  auto res = isl_union_set_solutions(copy());
+  auto res = isl_union_set_subtract(copy(), uset2.release());
   return manage(res);
 }
 
-isl::union_set union_set::subtract(isl::union_set uset2) const
+isl::union_set_list union_set::to_list() const
 {
-  auto res = isl_union_set_subtract(copy(), uset2.release());
+  auto res = isl_union_set_to_list(copy());
   return manage(res);
 }
 
 isl::union_set union_set::unite(isl::union_set uset2) const
 {
   auto res = isl_union_set_union(copy(), uset2.release());
   return manage(res);
 }
 
 isl::union_set union_set::universe() const
 {
   auto res = isl_union_set_universe(copy());
   return manage(res);
 }
 
 isl::union_map union_set::unwrap() const
 {
   auto res = isl_union_set_unwrap(copy());
   return manage(res);
 }
 
-isl::union_map union_set::wrapped_domain_map() const
+inline std::ostream &operator<<(std::ostream &os, const union_set &obj)
 {
-  auto res = isl_union_set_wrapped_domain_map(copy());
-  return manage(res);
+  char *str = isl_union_set_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::union_set_list
 union_set_list manage(__isl_take isl_union_set_list *ptr) {
   return union_set_list(ptr);
 }
 union_set_list manage_copy(__isl_keep isl_union_set_list *ptr) {
   ptr = isl_union_set_list_copy(ptr);
   return union_set_list(ptr);
 }
 
 union_set_list::union_set_list()
     : ptr(nullptr) {}
 
 union_set_list::union_set_list(const union_set_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 union_set_list::union_set_list(__isl_take isl_union_set_list *ptr)
     : ptr(ptr) {}
 
+union_set_list::union_set_list(isl::ctx ctx, int n)
+{
+  auto res = isl_union_set_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+union_set_list::union_set_list(isl::union_set el)
+{
+  auto res = isl_union_set_list_from_union_set(el.release());
+  ptr = res;
+}
+
+union_set_list::union_set_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_union_set_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 union_set_list &union_set_list::operator=(union_set_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 union_set_list::~union_set_list() {
   if (ptr)
__isl_give isl_union_set_list *union_set_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool union_set_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx union_set_list::ctx() const {
   return isl::ctx(isl_union_set_list_get_ctx(ptr));
 }
 
-void union_set_list::dump() const {
-  isl_union_set_list_dump(get());
-}
-
-
 isl::union_set_list union_set_list::add(isl::union_set el) const
 {
   auto res = isl_union_set_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::union_set_list union_set_list::alloc(isl::ctx ctx, int n)
+isl::union_set union_set_list::at(int index) const
 {
-  auto res = isl_union_set_list_alloc(ctx.release(), n);
+  auto res = isl_union_set_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::union_set union_set_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::union_set_list union_set_list::clear() const
 {
   auto res = isl_union_set_list_clear(copy());
   return manage(res);
 }
 
 isl::union_set_list union_set_list::concat(isl::union_set_list list2) const
 {
   auto res = isl_union_set_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::union_set_list union_set_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_union_set_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat union_set_list::foreach(const std::function<stat(union_set)> &fn) const
+stat union_set_list::foreach(const std::function<stat(isl::union_set)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(union_set)> *func;
-  } fn_data = { &fn };
+    std::function<stat(isl::union_set)> func;
+  } fn_data = { fn };
   auto fn_lambda = [](isl_union_set *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_union_set_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::union_set_list union_set_list::from_union_set(isl::union_set el)
-{
-  auto res = isl_union_set_list_from_union_set(el.release());
-  return manage(res);
-}
-
-isl::union_set union_set_list::get_at(int index) const
-{
-  auto res = isl_union_set_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::union_set union_set_list::get_union_set(int index) const
-{
-  auto res = isl_union_set_list_get_union_set(get(), index);
-  return manage(res);
-}
-
 isl::union_set_list union_set_list::insert(unsigned int pos, isl::union_set el) const
 {
   auto res = isl_union_set_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size union_set_list::n_union_set() const
-{
-  auto res = isl_union_set_list_n_union_set(get());
-  return res;
-}
-
-isl::union_set_list union_set_list::reverse() const
-{
-  auto res = isl_union_set_list_reverse(copy());
-  return manage(res);
-}
-
-isl::union_set_list union_set_list::set_union_set(int index, isl::union_set el) const
-{
-  auto res = isl_union_set_list_set_union_set(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size union_set_list::size() const
+class size union_set_list::size() const
 {
   auto res = isl_union_set_list_size(get());
-  return res;
-}
-
-isl::union_set_list union_set_list::swap(unsigned int pos1, unsigned int pos2) const
-{
-  auto res = isl_union_set_list_swap(copy(), pos1, pos2);
   return manage(res);
 }
 
-isl::union_set union_set_list::unite() const
+inline std::ostream &operator<<(std::ostream &os, const union_set_list &obj)
 {
-  auto res = isl_union_set_list_union(copy());
-  return manage(res);
+  char *str = isl_union_set_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
 
 // implementations for isl::val
 val manage(__isl_take isl_val *ptr) {
   return val(ptr);
 }
 val manage_copy(__isl_keep isl_val *ptr) {
   ptr = isl_val_copy(ptr);
   return val(ptr);
 }
 
 val::val()
     : ptr(nullptr) {}
 
 val::val(const val &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 val::val(__isl_take isl_val *ptr)
     : ptr(ptr) {}
 
 val::val(isl::ctx ctx, long i)
 {
   auto res = isl_val_int_from_si(ctx.release(), i);
   ptr = res;
 }
+
 val::val(isl::ctx ctx, const std::string &str)
 {
   auto res = isl_val_read_from_str(ctx.release(), str.c_str());
   ptr = res;
 }
 
 val &val::operator=(val obj) {
   std::swap(this->ptr, obj.ptr);
__isl_give isl_val *val::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool val::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx val::ctx() const {
   return isl::ctx(isl_val_get_ctx(ptr));
 }
 
-void val::dump() const {
-  isl_val_dump(get());
-}
-
-
 isl::val val::abs() const
 {
   auto res = isl_val_abs(copy());
   return manage(res);
 }
 
 boolean val::abs_eq(const isl::val &v2) const
 {
   auto res = isl_val_abs_eq(get(), v2.get());
   return manage(res);
 }
 
+boolean val::abs_eq(long v2) const
+{
+  return this->abs_eq(isl::val(ctx(), v2));
+}
+
 isl::val val::add(isl::val v2) const
 {
   auto res = isl_val_add(copy(), v2.release());
   return manage(res);
 }
 
-isl::val val::add_ui(unsigned long v2) const
+isl::val val::add(long v2) const
 {
-  auto res = isl_val_add_ui(copy(), v2);
-  return manage(res);
+  return this->add(isl::val(ctx(), v2));
 }
 
 isl::val val::ceil() const
 {
   auto res = isl_val_ceil(copy());
   return manage(res);
 }
 
 int val::cmp_si(long i) const
 {
   auto res = isl_val_cmp_si(get(), i);
   return res;
 }
 
+long val::den_si() const
+{
+  auto res = isl_val_get_den_si(get());
+  return res;
+}
+
+long val::get_den_si() const
+{
+  return den_si();
+}
+
 isl::val val::div(isl::val v2) const
 {
   auto res = isl_val_div(copy(), v2.release());
   return manage(res);
 }
 
-isl::val val::div_ui(unsigned long v2) const
+isl::val val::div(long v2) const
 {
-  auto res = isl_val_div_ui(copy(), v2);
-  return manage(res);
+  return this->div(isl::val(ctx(), v2));
 }
 
 boolean val::eq(const isl::val &v2) const
 {
   auto res = isl_val_eq(get(), v2.get());
   return manage(res);
 }
 
-boolean val::eq_si(long i) const
+boolean val::eq(long v2) const
 {
-  auto res = isl_val_eq_si(get(), i);
-  return manage(res);
+  return this->eq(isl::val(ctx(), v2));
 }
 
 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);
 }
 
-boolean val::ge(const isl::val &v2) const
+isl::val val::gcd(long v2) const
 {
-  auto res = isl_val_ge(get(), v2.get());
-  return manage(res);
+  return this->gcd(isl::val(ctx(), v2));
 }
 
-uint32_t val::get_hash() const
+boolean val::ge(const isl::val &v2) const
 {
-  auto res = isl_val_get_hash(get());
-  return res;
+  auto res = isl_val_ge(get(), v2.get());
+  return manage(res);
 }
 
-long val::get_num_si() const
+boolean val::ge(long v2) const
 {
-  auto res = isl_val_get_num_si(get());
-  return res;
+  return this->ge(isl::val(ctx(), v2));
 }
 
 boolean val::gt(const isl::val &v2) const
 {
   auto res = isl_val_gt(get(), v2.get());
   return manage(res);
 }
 
-boolean val::gt_si(long i) const
+boolean val::gt(long v2) const
 {
-  auto res = isl_val_gt_si(get(), i);
-  return manage(res);
+  return this->gt(isl::val(ctx(), v2));
 }
 
 isl::val val::infty(isl::ctx ctx)
 {
   auto res = isl_val_infty(ctx.release());
   return manage(res);
 }
 

 }
 
 boolean val::is_divisible_by(const isl::val &v2) const
 {
   auto res = isl_val_is_divisible_by(get(), v2.get());
   return manage(res);
 }
 
+boolean val::is_divisible_by(long v2) const
+{
+  return this->is_divisible_by(isl::val(ctx(), v2));
+}
+
 boolean val::is_infty() const
 {
   auto res = isl_val_is_infty(get());
   return manage(res);
 }
 
 boolean val::is_int() const
 {

 }
 
 boolean val::le(const isl::val &v2) const
 {
   auto res = isl_val_le(get(), v2.get());
   return manage(res);
 }
 
+boolean val::le(long v2) const
+{
+  return this->le(isl::val(ctx(), v2));
+}
+
 boolean val::lt(const isl::val &v2) const
 {
   auto res = isl_val_lt(get(), v2.get());
   return manage(res);
 }
 
+boolean val::lt(long v2) const
+{
+  return this->lt(isl::val(ctx(), v2));
+}
+
 isl::val val::max(isl::val v2) const
 {
   auto res = isl_val_max(copy(), v2.release());
   return manage(res);
 }
 
+isl::val val::max(long v2) const
+{
+  return this->max(isl::val(ctx(), v2));
+}
+
 isl::val val::min(isl::val v2) const
 {
   auto res = isl_val_min(copy(), v2.release());
   return manage(res);
 }
 
+isl::val val::min(long v2) const
+{
+  return this->min(isl::val(ctx(), v2));
+}
+
 isl::val val::mod(isl::val v2) const
 {
   auto res = isl_val_mod(copy(), v2.release());
   return manage(res);
 }
 
-isl::val val::mul(isl::val v2) const
+isl::val val::mod(long v2) const
 {
-  auto res = isl_val_mul(copy(), v2.release());
-  return manage(res);
+  return this->mod(isl::val(ctx(), v2));
 }
 
-isl::val val::mul_ui(unsigned long v2) const
+isl::val val::mul(isl::val v2) const
 {
-  auto res = isl_val_mul_ui(copy(), v2);
+  auto res = isl_val_mul(copy(), v2.release());
   return manage(res);
 }
 
-isl_size val::n_abs_num_chunks(size_t size) const
+isl::val val::mul(long v2) const
 {
-  auto res = isl_val_n_abs_num_chunks(get(), size);
-  return res;
+  return this->mul(isl::val(ctx(), v2));
 }
 
 isl::val val::nan(isl::ctx ctx)
 {
   auto res = isl_val_nan(ctx.release());
   return manage(res);
 }
 
 boolean val::ne(const isl::val &v2) const
 {
   auto res = isl_val_ne(get(), v2.get());
   return manage(res);
 }
 
+boolean val::ne(long v2) const
+{
+  return this->ne(isl::val(ctx(), v2));
+}
+
 isl::val val::neg() const
 {
   auto res = isl_val_neg(copy());
   return manage(res);
 }
 
 isl::val val::neginfty(isl::ctx ctx)
 {
   auto res = isl_val_neginfty(ctx.release());
   return manage(res);
 }
 
 isl::val val::negone(isl::ctx ctx)
 {
   auto res = isl_val_negone(ctx.release());
   return manage(res);
 }
 
+long val::num_si() const
+{
+  auto res = isl_val_get_num_si(get());
+  return res;
+}
+
+long val::get_num_si() const
+{
+  return num_si();
+}
+
 isl::val val::one(isl::ctx ctx)
 {
   auto res = isl_val_one(ctx.release());
   return manage(res);
 }
 
 isl::val val::pow2() const
 {
   auto res = isl_val_pow2(copy());
   return manage(res);
 }
 
-isl::val val::set_si(long i) const
-{
-  auto res = isl_val_set_si(copy(), i);
-  return manage(res);
-}
-
 int val::sgn() const
 {
   auto res = isl_val_sgn(get());
   return res;
 }
 
 isl::val val::sub(isl::val v2) const
 {
   auto res = isl_val_sub(copy(), v2.release());
   return manage(res);
 }
 
+isl::val val::sub(long v2) const
+{
+  return this->sub(isl::val(ctx(), v2));
+}
+
 isl::val val::sub_ui(unsigned long v2) const
 {
   auto res = isl_val_sub_ui(copy(), v2);
   return manage(res);
 }
 
+isl::val_list val::to_list() const
+{
+  auto res = isl_val_to_list(copy());
+  return manage(res);
+}
+
 isl::val val::trunc() const
 {
   auto res = isl_val_trunc(copy());
   return manage(res);
 }
 
 isl::val val::zero(isl::ctx ctx)
 {
   auto res = isl_val_zero(ctx.release());
   return manage(res);
 }
 
+inline std::ostream &operator<<(std::ostream &os, const val &obj)
+{
+  char *str = isl_val_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
 // implementations for isl::val_list
 val_list manage(__isl_take isl_val_list *ptr) {
   return val_list(ptr);
 }
 val_list manage_copy(__isl_keep isl_val_list *ptr) {
   ptr = isl_val_list_copy(ptr);
   return val_list(ptr);
 }
 
 val_list::val_list()
     : ptr(nullptr) {}
 
 val_list::val_list(const val_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
 
-
 val_list::val_list(__isl_take isl_val_list *ptr)
     : ptr(ptr) {}
 
+val_list::val_list(isl::ctx ctx, int n)
+{
+  auto res = isl_val_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+val_list::val_list(isl::val el)
+{
+  auto res = isl_val_list_from_val(el.release());
+  ptr = res;
+}
+
+val_list::val_list(isl::ctx ctx, const std::string &str)
+{
+  auto res = isl_val_list_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
 
 val_list &val_list::operator=(val_list obj) {
   std::swap(this->ptr, obj.ptr);
   return *this;
 }
 
 val_list::~val_list() {
   if (ptr)
__isl_give isl_val_list *val_list::release() {
   ptr = nullptr;
   return tmp;
 }
 
 bool val_list::is_null() const {
   return ptr == nullptr;
 }
 
-
 isl::ctx val_list::ctx() const {
   return isl::ctx(isl_val_list_get_ctx(ptr));
 }
 
-void val_list::dump() const {
-  isl_val_list_dump(get());
-}
-
-
 isl::val_list val_list::add(isl::val el) const
 {
   auto res = isl_val_list_add(copy(), el.release());
   return manage(res);
 }
 
-isl::val_list val_list::alloc(isl::ctx ctx, int n)
+isl::val_list val_list::add(long el) const
 {
-  auto res = isl_val_list_alloc(ctx.release(), n);
+  return this->add(isl::val(ctx(), el));
+}
+
+isl::val val_list::at(int index) const
+{
+  auto res = isl_val_list_get_at(get(), index);
   return manage(res);
 }
 
+isl::val val_list::get_at(int index) const
+{
+  return at(index);
+}
+
 isl::val_list val_list::clear() const
 {
   auto res = isl_val_list_clear(copy());
   return manage(res);
 }
 
 isl::val_list val_list::concat(isl::val_list list2) const
 {
   auto res = isl_val_list_concat(copy(), list2.release());
   return manage(res);
 }
 
 isl::val_list val_list::drop(unsigned int first, unsigned int n) const
 {
   auto res = isl_val_list_drop(copy(), first, n);
   return manage(res);
 }
 
-stat val_list::foreach(const std::function<stat(val)> &fn) const
+stat val_list::foreach(const std::function<stat(isl::val)> &fn) const
 {
   struct fn_data {
-    const std::function<stat(val)> *func;
-  } fn_data = { &fn };
+    std::function<stat(isl::val)> func;
+  } fn_data = { fn };
   auto fn_lambda = [](isl_val *arg_0, void *arg_1) -> isl_stat {
     auto *data = static_cast<struct fn_data *>(arg_1);
-    stat ret = (*data->func)(manage(arg_0));
+    auto ret = (data->func)(manage(arg_0));
     return ret.release();
   };
   auto res = isl_val_list_foreach(get(), fn_lambda, &fn_data);
   return manage(res);
 }
 
-isl::val_list val_list::from_val(isl::val el)
-{
-  auto res = isl_val_list_from_val(el.release());
-  return manage(res);
-}
-
-isl::val val_list::get_at(int index) const
-{
-  auto res = isl_val_list_get_at(get(), index);
-  return manage(res);
-}
-
-isl::val val_list::get_val(int index) const
-{
-  auto res = isl_val_list_get_val(get(), index);
-  return manage(res);
-}
-
 isl::val_list val_list::insert(unsigned int pos, isl::val el) const
 {
   auto res = isl_val_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
-isl_size val_list::n_val() const
+isl::val_list val_list::insert(unsigned int pos, long el) const
 {
-  auto res = isl_val_list_n_val(get());
-  return res;
+  return this->insert(pos, isl::val(ctx(), el));
 }
 
-isl::val_list val_list::reverse() const
-{
-  auto res = isl_val_list_reverse(copy());
-  return manage(res);
-}
-
-isl::val_list val_list::set_val(int index, isl::val el) const
-{
-  auto res = isl_val_list_set_val(copy(), index, el.release());
-  return manage(res);
-}
-
-isl_size val_list::size() const
+class size val_list::size() const
 {
   auto res = isl_val_list_size(get());
-  return res;
-}
-
-isl::val_list val_list::swap(unsigned int pos1, unsigned int pos2) const
-{
-  auto res = isl_val_list_swap(copy(), pos1, pos2);
-  return manage(res);
-}
-
-// implementations for isl::vec
-vec manage(__isl_take isl_vec *ptr) {
-  return vec(ptr);
-}
-vec manage_copy(__isl_keep isl_vec *ptr) {
-  ptr = isl_vec_copy(ptr);
-  return vec(ptr);
-}
-
-vec::vec()
-    : ptr(nullptr) {}
-
-vec::vec(const vec &obj)
-    : ptr(nullptr)
-{
-  ptr = obj.copy();
-}
-
-
-vec::vec(__isl_take isl_vec *ptr)
-    : ptr(ptr) {}
-
-
-vec &vec::operator=(vec obj) {
-  std::swap(this->ptr, obj.ptr);
-  return *this;
-}
-
-vec::~vec() {
-  if (ptr)
-    isl_vec_free(ptr);
-}
-
-__isl_give isl_vec *vec::copy() const & {
-  return isl_vec_copy(ptr);
-}
-
-__isl_keep isl_vec *vec::get() const {
-  return ptr;
-}
-
-__isl_give isl_vec *vec::release() {
-  isl_vec *tmp = ptr;
-  ptr = nullptr;
-  return tmp;
-}
-
-bool vec::is_null() const {
-  return ptr == nullptr;
-}
-
-
-isl::ctx vec::ctx() const {
-  return isl::ctx(isl_vec_get_ctx(ptr));
-}
-
-void vec::dump() const {
-  isl_vec_dump(get());
-}
-
-
-isl::vec vec::add(isl::vec vec2) const
-{
-  auto res = isl_vec_add(copy(), vec2.release());
-  return manage(res);
-}
-
-isl::vec vec::add_els(unsigned int n) const
-{
-  auto res = isl_vec_add_els(copy(), n);
-  return manage(res);
-}
-
-isl::vec vec::alloc(isl::ctx ctx, unsigned int size)
-{
-  auto res = isl_vec_alloc(ctx.release(), size);
   return manage(res);
 }
 
-isl::vec vec::ceil() const
+inline std::ostream &operator<<(std::ostream &os, const val_list &obj)
 {
-  auto res = isl_vec_ceil(copy());
-  return manage(res);
-}
-
-isl::vec vec::clr() const
-{
-  auto res = isl_vec_clr(copy());
-  return manage(res);
-}
-
-int vec::cmp_element(const isl::vec &vec2, int pos) const
-{
-  auto res = isl_vec_cmp_element(get(), vec2.get(), pos);
-  return res;
-}
-
-isl::vec vec::concat(isl::vec vec2) const
-{
-  auto res = isl_vec_concat(copy(), vec2.release());
-  return manage(res);
-}
-
-isl::vec vec::drop_els(unsigned int pos, unsigned int n) const
-{
-  auto res = isl_vec_drop_els(copy(), pos, n);
-  return manage(res);
-}
-
-isl::vec vec::extend(unsigned int size) const
-{
-  auto res = isl_vec_extend(copy(), size);
-  return manage(res);
-}
-
-isl::val vec::get_element_val(int pos) const
-{
-  auto res = isl_vec_get_element_val(get(), pos);
-  return manage(res);
-}
-
-isl::vec vec::insert_els(unsigned int pos, unsigned int n) const
-{
-  auto res = isl_vec_insert_els(copy(), pos, n);
-  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);
-}
-
-boolean vec::is_equal(const isl::vec &vec2) const
-{
-  auto res = isl_vec_is_equal(get(), vec2.get());
-  return manage(res);
-}
-
-isl::vec vec::mat_product(isl::mat mat) const
-{
-  auto res = isl_vec_mat_product(copy(), mat.release());
-  return manage(res);
-}
-
-isl::vec vec::move_els(unsigned int dst_col, unsigned int src_col, unsigned int n) const
-{
-  auto res = isl_vec_move_els(copy(), dst_col, src_col, n);
-  return manage(res);
-}
-
-isl::vec vec::neg() const
-{
-  auto res = isl_vec_neg(copy());
-  return manage(res);
-}
-
-isl::vec vec::set_element_si(int pos, int v) const
-{
-  auto res = isl_vec_set_element_si(copy(), pos, v);
-  return manage(res);
-}
-
-isl::vec vec::set_element_val(int pos, isl::val v) const
-{
-  auto res = isl_vec_set_element_val(copy(), pos, v.release());
-  return manage(res);
-}
-
-isl::vec vec::set_si(int v) const
-{
-  auto res = isl_vec_set_si(copy(), v);
-  return manage(res);
-}
-
-isl::vec vec::set_val(isl::val v) const
-{
-  auto res = isl_vec_set_val(copy(), v.release());
-  return manage(res);
-}
-
-isl_size vec::size() const
-{
-  auto res = isl_vec_size(get());
-  return res;
-}
-
-isl::vec vec::sort() const
-{
-  auto res = isl_vec_sort(copy());
-  return manage(res);
-}
-
-isl::vec vec::zero(isl::ctx ctx, unsigned int size)
-{
-  auto res = isl_vec_zero(ctx.release(), size);
-  return manage(res);
-}
-
-isl::vec vec::zero_extend(unsigned int size) const
-{
-  auto res = isl_vec_zero_extend(copy(), size);
-  return manage(res);
+  char *str = isl_val_list_to_str(obj.get());
+  if (!str) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+  os << str;
+  free(str);
+  return os;
 }
-} // namespace noexceptions 
 } // namespace isl
 
 #endif /* ISL_CPP_CHECKED */

polly/lib/Support/GICHelper.cpp

 /// To call a inline dump() method in a debugger, at it must have been
 /// instantiated in at least one translation unit. Because isl's dump() method
 /// are meant to be called from a debugger only, but not from code, no such
 /// instantiation would exist. We use this method to force an instantiation in
 /// this translation unit. Because it has non-static linking, the compiler does
 /// not know that it is never called, and therefore must ensure the existence of
 /// the dump functions.
 void neverCalled() {
-  isl::aff().dump();
-  isl::aff_list().dump();
-  isl::ast_expr().dump();
-  isl::ast_expr_list().dump();
-  isl::ast_node().dump();
-  isl::ast_node_list().dump();
-  isl::basic_map().dump();
-  isl::basic_map_list().dump();
-  isl::basic_set().dump();
-  isl::basic_set_list().dump();
-  isl::constraint().dump();
-  isl::constraint_list().dump();
-  isl::id().dump();
-  isl::id_list().dump();
-  isl::id_to_ast_expr().dump();
-  isl::local_space().dump();
-  isl::map().dump();
-  isl::map_list().dump();
-  isl::multi_aff().dump();
-  isl::multi_pw_aff().dump();
-  isl::multi_union_pw_aff().dump();
-  isl::multi_val().dump();
-  isl::point().dump();
-  isl::pw_aff().dump();
-  isl::pw_aff_list().dump();
-  isl::pw_multi_aff().dump();
-  isl::pw_qpolynomial().dump();
-  isl::qpolynomial().dump();
-  isl::schedule().dump();
-  isl::schedule_constraints().dump();
-  isl::schedule_node().dump();
-  isl::set().dump();
-  isl::set_list().dump();
-  isl::space().dump();
-  isl::union_map().dump();
-  isl::union_map_list().dump();
-  isl::union_pw_aff().dump();
-  isl::union_pw_aff_list().dump();
-  isl::union_pw_multi_aff().dump();
-  isl::union_pw_multi_aff_list().dump();
-  isl::union_set().dump();
-  isl::union_set_list().dump();
-  isl::val().dump();
-  isl::val_list().dump();
+  polly::dumpIslObj(isl::aff());
+  polly::dumpIslObj(isl::aff_list());
+  polly::dumpIslObj(isl::ast_expr());
+  polly::dumpIslObj(isl::ast_node());
+  polly::dumpIslObj(isl::ast_node_list());
+  polly::dumpIslObj(isl::basic_map());
+  polly::dumpIslObj(isl::basic_map_list());
+  polly::dumpIslObj(isl::basic_set());
+  polly::dumpIslObj(isl::basic_set_list());
+  polly::dumpIslObj(isl::constraint());
+  polly::dumpIslObj(isl::id());
+  polly::dumpIslObj(isl::id_list());
+  polly::dumpIslObj(isl::id_to_ast_expr());
+  polly::dumpIslObj(isl::local_space());
+  polly::dumpIslObj(isl::map());
+  polly::dumpIslObj(isl::map_list());
+  polly::dumpIslObj(isl::multi_aff());
+  polly::dumpIslObj(isl::multi_pw_aff());
+  polly::dumpIslObj(isl::multi_union_pw_aff());
+  polly::dumpIslObj(isl::multi_val());
+  polly::dumpIslObj(isl::point());
+  polly::dumpIslObj(isl::pw_aff());
+  polly::dumpIslObj(isl::pw_aff_list());
+  polly::dumpIslObj(isl::pw_multi_aff());
+  polly::dumpIslObj(isl::schedule());
+  polly::dumpIslObj(isl::schedule_constraints());
+  polly::dumpIslObj(isl::schedule_node());
+  polly::dumpIslObj(isl::set());
+  polly::dumpIslObj(isl::set_list());
+  polly::dumpIslObj(isl::space());
+  polly::dumpIslObj(isl::union_map());
+  polly::dumpIslObj(isl::union_pw_aff());
+  polly::dumpIslObj(isl::union_pw_aff_list());
+  polly::dumpIslObj(isl::union_pw_multi_aff());
+  polly::dumpIslObj(isl::union_set());
+  polly::dumpIslObj(isl::union_set_list());
+  polly::dumpIslObj(isl::val());
+  polly::dumpIslObj(isl::val_list());
 }
 #endif

polly/lib/Support/ISLTools.cpp

 /// @param Pos    Position to shift.
 /// @param Amount Value added to the shifted dimension.
 ///
 /// @return An isl_multi_aff for the map with this shifted dimension.
 isl::multi_aff makeShiftDimAff(isl::space Space, int Pos, int Amount) {
   auto Identity = isl::multi_aff::identity(Space);
   if (Amount == 0)
     return Identity;
-  auto ShiftAff = Identity.get_aff(Pos);
+  auto ShiftAff = Identity.at(Pos);
   ShiftAff = ShiftAff.set_constant_si(Amount);
   return Identity.set_aff(Pos, ShiftAff);
 }
 
 /// 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) {
   // Fast-path on out-of-quota.
   if (FromSpace1.is_null() || FromSpace2.is_null())
     return {};
 
   assert(FromSpace1.is_set());
   assert(FromSpace2.is_set());
 
-  unsigned Dims1 = FromSpace1.dim(isl::dim::set);
-  unsigned Dims2 = FromSpace2.dim(isl::dim::set);
+  isl::size Dim = FromSpace1.dim(isl::dim::set);
+  IslAssertNoError(Dim);
+  unsigned Dims1 = static_cast<unsigned>(Dim);
+  Dim = FromSpace2.dim(isl::dim::set);
+  IslAssertNoError(Dim);
+  unsigned Dims2 = static_cast<unsigned>(Dim);
 
   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::basic_map Result = isl::basic_map::universe(MapSpace);
   for (unsigned i = 0u; i < Dims1; i += 1)
isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
 
   isl::set Result(USet);
   assert(Result.is_null() ||
          Result.get_space().has_equal_tuples(ExpectedSpace));
 
   return Result;
 }
 
-isl_size polly::getNumScatterDims(const isl::union_map &Schedule) {
+unsigned polly::getNumScatterDims(const isl::union_map &Schedule) {
   isl_size Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
     if (Map.is_null())
       continue;
 
-    Dims = std::max(Dims, Map.range_tuple_dim());
+    Dims = std::max(Dims, Map.range_tuple_dim().release());
   }
+  assert(Dims >= 0);
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
   if (Schedule.is_null())
     return {};
   unsigned Dims = getNumScatterDims(Schedule);
   isl::space ScatterSpace = Schedule.get_space().set_from_params();
isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
   for (isl::map Map : UMap.get_map_list()) {
     auto Reversed = reverseDomain(std::move(Map));
     Result = Result.unite(Reversed);
   }
   return Result;
 }
 
 isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
-  int NumDims = Set.tuple_dim();
+  isl::size Dim = Set.tuple_dim();
+  IslAssertNoError(Dim);
+  int NumDims = static_cast<unsigned>(Dim);
   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.ctx());
   for (isl::set Set : USet.get_set_list()) {
     isl::set Shifted = shiftDim(Set, Pos, Amount);
     Result = Result.unite(Shifted);
   }
   return Result;
 }
 
 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
-  int NumDims = Map.dim(Dim);
+  isl::size MapDim = Map.dim(Dim);
+  IslAssertNoError(MapDim);
+  int NumDims = static_cast<unsigned>(MapDim);
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   isl::space Space = Map.get_space();
   switch (Dim) {
   case isl::dim::in:
     Space = Space.domain();
     break;
isl::map polly::distributeDomain(isl::map Map) {
   // Note that we cannot take Map apart into { Domain[] -> Range1[] } and {
   // Domain[] -> Range2[] } and combine again. We would loose any relation
   // between Range1[] and Range2[] that is not also a constraint to Domain[].
 
   isl::space Space = Map.get_space();
   isl::space DomainSpace = Space.domain();
   if (DomainSpace.is_null())
     return {};
-  unsigned DomainDims = DomainSpace.dim(isl::dim::set);
+  isl::size Dim = DomainSpace.dim(isl::dim::set);
+  if (Dim.is_error())
+    return {};
+  unsigned DomainDims = static_cast<unsigned>(Dim);
+
   isl::space RangeSpace = Space.range().unwrap();
   isl::space Range1Space = RangeSpace.domain();
   if (Range1Space.is_null())
     return {};
-  unsigned Range1Dims = Range1Space.dim(isl::dim::set);
+  Dim = Range1Space.dim(isl::dim::set);
+  if (Dim.is_error())
+    return {};
+  unsigned Range1Dims = static_cast<unsigned>(Dim);
+
   isl::space Range2Space = RangeSpace.range();
   if (Range2Space.is_null())
     return {};
-  unsigned Range2Dims = Range2Space.dim(isl::dim::set);
+  Dim = Range2Space.dim(isl::dim::set);
+  if (Dim.is_error())
+    return {};
+  unsigned Range2Dims = static_cast<unsigned>(Dim);
 
   isl::space OutputSpace =
       DomainSpace.map_from_domain_and_range(Range1Space)
           .wrap()
           .map_from_domain_and_range(
               DomainSpace.map_from_domain_and_range(Range2Space).wrap());
 
   isl::basic_map Translator = isl::basic_map::universe(

 ///
 /// Ordering is based on the lower bounds of the set's dimensions. First
 /// dimensions are considered first.
 static int flatCompare(const isl::basic_set &A, const isl::basic_set &B) {
   // Quick bail-out on out-of-quota.
   if (A.is_null() || B.is_null())
     return 0;
 
-  unsigned ALen = A.dim(isl::dim::set);
-  unsigned BLen = B.dim(isl::dim::set);
+  isl::size Dim = A.dim(isl::dim::set);
+  if (Dim.is_error())
+    return 0;
+  unsigned ALen = static_cast<unsigned>(Dim);
+  Dim = B.dim(isl::dim::set);
+  if (Dim.is_error())
+    return 0;
+  unsigned BLen = static_cast<unsigned>(Dim);
   unsigned Len = std::min(ALen, BLen);
 
   for (unsigned i = 0; i < Len; i += 1) {
     isl::basic_set ADim =
-        A.project_out(isl::dim::param, 0, A.dim(isl::dim::param))
+        A.project_out(isl::dim::param, 0, A.dim(isl::dim::param).release())
             .project_out(isl::dim::set, i + 1, ALen - i - 1)
             .project_out(isl::dim::set, 0, i);
     isl::basic_set BDim =
-        B.project_out(isl::dim::param, 0, B.dim(isl::dim::param))
+        B.project_out(isl::dim::param, 0, B.dim(isl::dim::param).release())
             .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));
static int structureCompare(const isl::space &ASpace, const isl::space &BSpace,
   if (!BSpace.is_params() && BSpace.has_tuple_name(isl::dim::set))
     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);
+    int LenCompare = BSpace.dim(isl::dim::set).release() -
+                     ASpace.dim(isl::dim::set).release();
     if (LenCompare != 0)
       return LenCompare;
   }
 
   return 0;
 }
 
 /// Compare the sets @p A and @p B according to their nested space structure. If
for (const isl::basic_set &BSet : BSets) {
 
     OS << llvm::StringRef(Str).substr(OpenPos + 1, ClosePos - OpenPos - 2);
     First = false;
   }
   assert(!First);
   OS << "\n}\n";
 }
 
-static void recursiveExpand(isl::basic_set BSet, int Dim, isl::set &Expanded) {
-  int Dims = BSet.dim(isl::dim::set);
+static void recursiveExpand(isl::basic_set BSet, unsigned Dim,
+                            isl::set &Expanded) {
+  isl::size BSetDim = BSet.dim(isl::dim::set);
+  IslAssertNoError(BSetDim);
+  unsigned Dims = static_cast<unsigned>(BSetDim);
   if (Dim >= Dims) {
     Expanded = Expanded.unite(BSet);
     return;
   }
 
   isl::basic_set DimOnly =
-      BSet.project_out(isl::dim::param, 0, BSet.dim(isl::dim::param))
+      BSet.project_out(isl::dim::param, 0, BSet.dim(isl::dim::param).release())
           .project_out(isl::dim::set, Dim + 1, Dims - Dim - 1)
           .project_out(isl::dim::set, 0, Dim);
   if (!DimOnly.is_bounded()) {
     recursiveExpand(BSet, Dim + 1, Expanded);
     return;
   }
 
   foreachPoint(DimOnly, [&, Dim](isl::point P) {

 
 LLVM_DUMP_METHOD void polly::dumpExpanded(__isl_keep isl_union_set *USet) {
   dumpExpanded(isl::manage_copy(USet));
 }
 
 LLVM_DUMP_METHOD void polly::dumpExpanded(__isl_keep isl_union_map *UMap) {
   dumpExpanded(isl::manage_copy(UMap));
 }
+
+llvm::iota_range<unsigned> polly::rangeIslSize(unsigned Begin, isl::size End) {
+  IslAssertNoError(End);
+  unsigned UEnd = static_cast<unsigned>(End);
+  return llvm::seq<unsigned>(std::min(Begin, UEnd), UEnd);
+}
 #endif

polly/lib/Transform/FlattenAlgo.cpp

 using namespace llvm;
 
 namespace {
 
 /// Whether a dimension of a set is bounded (lower and upper) by a constant,
 /// 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);
+  isl::size Size = Set.dim(isl::dim::param);
+  IslAssertNoError(Size);
+  auto ParamDims = static_cast<unsigned>(Size);
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.tuple_dim();
+  Size = Set.tuple_dim();
+  IslAssertNoError(Size);
+  auto SetDims = static_cast<unsigned>(Size);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// 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.tuple_dim();
+  isl::size Dim = Set.tuple_dim();
+  IslAssertNoError(Dim);
+  auto SetDims = static_cast<unsigned>(Dim);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// 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.is_null() || FixedVal.is_nan();
isl::union_map scheduleProjectOut(const isl::union_map &UMap, unsigned first,
   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.
-isl_size scheduleScatterDims(const isl::union_map &Schedule) {
+unsigned scheduleScatterDims(const isl::union_map &Schedule) {
   isl_size Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
     if (Map.is_null())
       continue;
 
-    Dims = std::max(Dims, Map.range_tuple_dim());
+    Dims = std::max(Dims, Map.range_tuple_dim().release());
   }
+  assert(Dims >= 0);
   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.ctx());
   for (isl::map Map : UMap.get_map_list()) {
-    unsigned MapDims = Map.range_tuple_dim();
+    isl::size Dim = Map.range_tuple_dim();
+    IslAssertNoError(Dim);
+    unsigned MapDims = static_cast<unsigned>(Dim);
     isl::map SingleMap = Map.project_out(isl::dim::out, 0, pos);
     SingleMap = SingleMap.project_out(isl::dim::out, 1, MapDims - pos - 1);
     SingleUMap = SingleUMap.unite(SingleMap);
   };
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
   auto FirstMAff = isl::multi_union_pw_aff(UAff);
-  return FirstMAff.get_union_pw_aff(0);
+  return FirstMAff.at(0);
 }
 
 /// Flatten a sequence-like first dimension.
 ///
 /// A sequence-like scatter dimension is constant, or at least only small
 /// variation, typically the result of ordering a sequence of different
 /// statements. An example would be:
 ///   { Stmt_A[] -> [0, X, ...]; Stmt_B[] -> [1, Y, ...] }

 /// left.
 /// The example schedule would be transformed to:
 ///   { Stmt_X[] -> [X - l_X, ...]; Stmt_B -> [l_X - u_X + 1 + Y - l_Y, ...] }
 isl::union_map tryFlattenSequence(isl::union_map Schedule) {
   auto IslCtx = Schedule.ctx();
   auto ScatterSet = isl::set(Schedule.range());
 
   auto ParamSpace = Schedule.get_space().params();
-  auto Dims = ScatterSet.tuple_dim();
+  isl::size Size = ScatterSet.tuple_dim();
+  IslAssertNoError(Size);
+  auto Dims = static_cast<unsigned>(Size);
   assert(Dims >= 2);
 
   // Would cause an infinite loop.
   if (!isDimBoundedByConstant(ScatterSet, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
     return {};
   }
 
while (!ScatterSet.is_empty()) {
     auto PartLen = PartMax.add(PartMin.neg()).add(One);
 
     auto AllPartMin = isl::union_pw_aff(PartMin).pullback(AllDomainsToNull);
     auto FirstScheduleAffNormalized = FirstScheduleAff.sub(AllPartMin);
     auto AllCounter = isl::union_pw_aff(Counter).pullback(AllDomainsToNull);
     auto FirstScheduleAffWithOffset =
         FirstScheduleAffNormalized.add(AllCounter);
 
-    auto ScheduleWithOffset = isl::union_map(FirstScheduleAffWithOffset)
-                                  .flat_range_product(RemainingSubSchedule);
+    auto ScheduleWithOffset =
+        isl::union_map::from(
+            isl::union_pw_multi_aff(FirstScheduleAffWithOffset))
     NewSchedule = NewSchedule.unite(ScheduleWithOffset);
 
     ScatterSet = ScatterSet.subtract(ScatterFirst);
     Counter = Counter.add(PartLen);
   }
 
   LLVM_DEBUG(dbgs() << "Sequence-flatten result is:\n  " << NewSchedule
                     << "\n");

 isl::union_map tryFlattenLoop(isl::union_map Schedule) {
   assert(scheduleScatterDims(Schedule) >= 2);
 
   auto Remaining = scheduleProjectOut(Schedule, 0, 1);
   auto SubSchedule = flattenSchedule(Remaining);
   auto SubDims = scheduleScatterDims(SubSchedule);
 
   auto SubExtent = isl::set(SubSchedule.range());
-  auto SubExtentDims = SubExtent.dim(isl::dim::param);
+  auto SubExtentDims = SubExtent.dim(isl::dim::param).release();
   SubExtent = SubExtent.project_out(isl::dim::param, 0, SubExtentDims);
   SubExtent = SubExtent.project_out(isl::dim::set, 1, SubDims - 1);
 
   if (!isDimBoundedByConstant(SubExtent, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension not bounded by constant\n");
     return {};
   }
 
   auto Min = SubExtent.dim_min(0);
   LLVM_DEBUG(dbgs() << "Min bound:\n  " << Min << "\n");
   auto MinVal = getConstant(Min, false, true);
   auto Max = SubExtent.dim_max(0);
   LLVM_DEBUG(dbgs() << "Max bound:\n  " << Max << "\n");
   auto MaxVal = getConstant(Max, true, false);
 
   if (MinVal.is_null() || MaxVal.is_null() || MinVal.is_nan() ||
       MaxVal.is_nan()) {
     LLVM_DEBUG(dbgs() << "Abort; dimension bounds could not be determined\n");
     return {};
   }
 
   auto FirstSubScheduleAff = scheduleExtractDimAff(SubSchedule, 0);
   auto RemainingSubSchedule = scheduleProjectOut(std::move(SubSchedule), 0, 1);
 
-  auto LenVal = MaxVal.sub(MinVal).add_ui(1);
+  auto LenVal = MaxVal.sub(MinVal).add(1);
   auto FirstSubScheduleNormalized = subtract(FirstSubScheduleAff, MinVal);
 
   // TODO: Normalize FirstAff to zero (convert to isl_map, determine minimum,
   // subtract it)
   auto FirstAff = scheduleExtractDimAff(Schedule, 0);
   auto Offset = multiply(FirstAff, LenVal);
-  auto Index = FirstSubScheduleNormalized.add(Offset);
-  auto IndexMap = isl::union_map(Index);
+  isl::union_pw_multi_aff Index = FirstSubScheduleNormalized.add(Offset);
+  auto IndexMap = isl::union_map::from(Index);
 
   auto Result = IndexMap.flat_range_product(RemainingSubSchedule);
   LLVM_DEBUG(dbgs() << "Loop-flatten result is:\n  " << Result << "\n");
   return Result;
 }
 } // anonymous namespace
 
 isl::union_map polly::flattenSchedule(isl::union_map Schedule) {

polly/lib/Transform/MatmulOptimizer.cpp

 ///
 /// @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.
 static isl::map permuteDimensions(isl::map Map, isl::dim DimType,
                                   unsigned DstPos, unsigned SrcPos) {
-  assert((isl_size)DstPos < Map.dim(DimType) &&
-         (isl_size)SrcPos < Map.dim(DimType));
+  assert((isl_size)DstPos < Map.dim(DimType).release() &&
+         (isl_size)SrcPos < Map.dim(DimType).release());
   if (DstPos == SrcPos)
     return Map;
   isl::id DimId;
   if (Map.has_tuple_id(DimType))
     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))

 ///                  second output dimension.
 /// @return          True in case @p AccMap has the expected form and false,
 ///                  otherwise.
 static bool isMatMulOperandAcc(isl::set Domain, isl::map AccMap, int &FirstPos,
                                int &SecondPos) {
   isl::space Space = AccMap.get_space();
   isl::map Universe = isl::map::universe(Space);
 
-  if (Space.dim(isl::dim::out) != 2)
+  if (Space.dim(isl::dim::out).release() != 2)
     return false;
 
   // MatMul has the form:
   // for (i = 0; i < N; i++)
   //   for (j = 0; j < M; j++)
   //     for (k = 0; k < P; k++)
   //       C[i, j] += A[i, k] * B[k, j]
   //

 /// @param  MMI             Parameters of the matrix multiplication operands.
 /// @return                 True in case the corresponding SCoP statement
 ///                         represents matrix multiplication and false,
 ///                         otherwise.
 static bool containsOnlyMatrMultAcc(isl::map PartialSchedule,
                                     MatMulInfoTy &MMI) {
   auto InputDimId = PartialSchedule.get_tuple_id(isl::dim::in);
   auto *Stmt = static_cast<ScopStmt *>(InputDimId.get_user());
-  isl_size OutDimNum = PartialSchedule.range_tuple_dim();
+  isl_size OutDimNum = PartialSchedule.range_tuple_dim().release();
   assert(OutDimNum > 2 && "In case of the matrix multiplication the loop nest "
                           "and, consequently, the corresponding scheduling "
                           "functions have at least three dimensions.");
   auto MapI =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.i, OutDimNum - 1);
   auto MapJ =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.j, OutDimNum - 1);
   auto MapK =
static bool containsOnlyMatMulDep(isl::map Schedule, const Dependences *D,
                                   int &Pos) {
   isl::union_map Dep = D->getDependences(Dependences::TYPE_RAW);
   isl::union_map Red = D->getDependences(Dependences::TYPE_RED);
   if (!Red.is_null())
     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();
-  isl_size DeltasDimNum = Deltas.dim(isl::dim::set);
+  isl_size DeltasDimNum = Deltas.dim(isl::dim::set).release();
   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())))
       return false;
   }
   if (DeltasDimNum == 0 || Pos < 0)
     return false;

 static isl::schedule_node permuteBandNodeDimensions(isl::schedule_node Node,
                                                     unsigned FirstDim,
                                                     unsigned SecondDim) {
   assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band &&
          (unsigned)isl_schedule_node_band_n_member(Node.get()) >
              std::max(FirstDim, SecondDim));
   auto PartialSchedule =
       isl::manage(isl_schedule_node_band_get_partial_schedule(Node.get()));
-  auto PartialScheduleFirstDim = PartialSchedule.get_union_pw_aff(FirstDim);
-  auto PartialScheduleSecondDim = PartialSchedule.get_union_pw_aff(SecondDim);
+  auto PartialScheduleFirstDim = PartialSchedule.at(FirstDim);
+  auto PartialScheduleSecondDim = PartialSchedule.at(SecondDim);
   PartialSchedule =
       PartialSchedule.set_union_pw_aff(SecondDim, PartialScheduleFirstDim);
   PartialSchedule =
       PartialSchedule.set_union_pw_aff(FirstDim, PartialScheduleSecondDim);
   Node = isl::manage(isl_schedule_node_delete(Node.release()));
   return Node.insert_partial_schedule(PartialSchedule);
 }
 
createMacroKernel(isl::schedule_node Node,
   TileSizes[DimOutNum - 2] = MacroKernelParams.Nc;
   TileSizes[DimOutNum - 1] = MacroKernelParams.Kc;
   Node = tileNode(Node, "1st level tiling", TileSizes, 1);
   Node = Node.parent().parent();
   Node = permuteBandNodeDimensions(Node, DimOutNum - 2, DimOutNum - 1);
   Node = permuteBandNodeDimensions(Node, DimOutNum - 3, DimOutNum - 1);
 
   // Mark the outermost loop as parallelizable.
-  Node = Node.band_member_set_coincident(0, true);
+  Node = Node.as<isl::schedule_node_band>().member_set_coincident(0, true);
 
   return Node.child(0).child(0);
 }
 
 /// Get the size of the widest type of the matrix multiplication operands
 /// in bytes, including alignment padding.
 ///
 /// @param MMI Parameters of the matrix multiplication operands.
AccRelPackedB =
       AccRelPackedB.set_tuple_id(isl::dim::out, PackedB->getBasePtrId());
 
   // Create the copy statement and redirect access.
   ScopStmt *CopyStmt = S->addScopStmt(AccRelB, AccRelPackedB, Domain);
   MMI.B->setNewAccessRelation(AccRelPackedB);
 
   // Insert into the schedule tree.
   isl::map ExtMap = MapOldIndVar.project_out(
-      isl::dim::out, 2, MapOldIndVar.range_tuple_dim() - 2);
+      isl::dim::out, 2, MapOldIndVar.range_tuple_dim().release() - 2);
   ExtMap = ExtMap.reverse();
   ExtMap = ExtMap.fix_si(isl::dim::out, MMI.i, 0);
   ExtMap = ExtMap.intersect_range(Domain);
   ExtMap = ExtMap.set_tuple_id(isl::dim::out, CopyStmt->getDomainId());
   return createExtensionNode(Node, ExtMap);
 }
 
 static isl::schedule_node optimizePackedA(isl::schedule_node Node, ScopStmt *,

 /// @see getMacroKernelParams
 static isl::map
 getInductionVariablesSubstitution(isl::schedule_node Node,
                                   MicroKernelParamsTy MicroKernelParams,
                                   MacroKernelParamsTy MacroKernelParams) {
   auto Child = Node.child(0);
   auto UnMapOldIndVar = Child.get_prefix_schedule_union_map();
   auto MapOldIndVar = isl::map::from_union_map(UnMapOldIndVar);
-  if (MapOldIndVar.range_tuple_dim() > 9)
-    return MapOldIndVar.project_out(isl::dim::out, 0,
-                                    MapOldIndVar.range_tuple_dim() - 9);
+  if (MapOldIndVar.range_tuple_dim().release() > 9)
+    return MapOldIndVar.project_out(
+        isl::dim::out, 0, MapOldIndVar.range_tuple_dim().release() - 9);
   return MapOldIndVar;
 }
 
 /// Isolate a set of partial tile prefixes and unroll the isolated part.
 ///
 /// The set should ensure that it contains only partial tile prefixes that have
 /// exactly Mr x Nr iterations of the two innermost loops produced by
 /// the optimization of the matrix multiplication. Mr and Nr are parameters of
 /// the micro-kernel.
 ///
 /// In case of parametric bounds, this helps to auto-vectorize the unrolled
 /// innermost loops, using the SLP vectorizer.
 ///
 /// @param Node              The schedule node to be modified.
 /// @param MicroKernelParams Parameters of the micro-kernel
 ///                          to be taken into account.
 /// @return The modified isl_schedule_node.
 static isl::schedule_node
 isolateAndUnrollMatMulInnerLoops(isl::schedule_node Node,
                                  struct MicroKernelParamsTy MicroKernelParams) {
-  isl::schedule_node Child = Node.get_child(0);
+  isl::schedule_node Child = Node.child(0);
   isl::union_map UnMapOldIndVar = Child.get_prefix_schedule_relation();
   isl::set Prefix = isl::map::from_union_map(UnMapOldIndVar).range();
-  isl_size Dims = Prefix.tuple_dim();
+  isl_size Dims = Prefix.tuple_dim().release();
   Prefix = Prefix.project_out(isl::dim::set, Dims - 1, 1);
   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Nr);
   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Mr);
 
   isl::union_set IsolateOption =
       getIsolateOptions(Prefix.add_dims(isl::dim::set, 3), 3);
   isl::ctx Ctx = Node.ctx();
   auto Options = IsolateOption.unite(getDimOptions(Ctx, "unroll"));
   Options = Options.unite(getUnrollIsolatedSetOptions(Ctx));
-  Node = Node.band_set_ast_build_options(Options);
+  Node = Node.as<isl::schedule_node_band>().set_ast_build_options(Options);
   Node = Node.parent().parent().parent();
   IsolateOption = getIsolateOptions(Prefix, 3);
   Options = IsolateOption.unite(getDimOptions(Ctx, "separate"));
-  Node = Node.band_set_ast_build_options(Options);
+  Node = Node.as<isl::schedule_node_band>().set_ast_build_options(Options);
   Node = Node.child(0).child(0).child(0);
   return Node;
 }
 
 /// Mark @p BasePtr with "Inter iteration alias-free" mark node.
 ///
 /// @param Node The child of the mark node to be inserted.
 /// @param BasePtr The pointer to be marked.

 /// @return The modified schedule node.
 static isl::schedule_node
 getBandNodeWithOriginDimOrder(isl::schedule_node Node) {
   assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band);
   if (isl_schedule_node_get_type(Node.child(0).get()) != isl_schedule_node_leaf)
     return Node;
   auto Domain = Node.get_universe_domain();
   assert(isl_union_set_n_set(Domain.get()) == 1);
-  if (Node.get_schedule_depth() != 0 ||
-      (isl::set(Domain).tuple_dim() !=
+  if (Node.get_schedule_depth().release() != 0 ||
+      (isl::set(Domain).tuple_dim().release() !=
        isl_schedule_node_band_n_member(Node.get())))
     return Node;
   Node = isl::manage(isl_schedule_node_delete(Node.copy()));
   auto PartialSchedulePwAff = Domain.identity_union_pw_multi_aff();
   auto PartialScheduleMultiPwAff =
       isl::multi_union_pw_aff(PartialSchedulePwAff);
   PartialScheduleMultiPwAff =
       PartialScheduleMultiPwAff.reset_tuple_id(isl::dim::set);
static bool isMatrMultPattern(isl::schedule_node Node, const Dependences *D,
                               MatMulInfoTy &MMI) {
   auto PartialSchedule = isl::manage(
       isl_schedule_node_band_get_partial_schedule_union_map(Node.get()));
   Node = Node.child(0);
   auto LeafType = isl_schedule_node_get_type(Node.get());
   Node = Node.parent();
   if (LeafType != isl_schedule_node_leaf ||
       isl_schedule_node_band_n_member(Node.get()) < 3 ||
-      Node.get_schedule_depth() != 0 ||
+      Node.get_schedule_depth().release() != 0 ||
       isl_union_map_n_map(PartialSchedule.get()) != 1)
     return false;
   auto NewPartialSchedule = isl::map::from_union_map(PartialSchedule);
   if (containsMatrMult(NewPartialSchedule, D, MMI))
     return true;
   return false;
 }
 

polly/lib/Transform/MaximalStaticExpansion.cpp

 };
 } // namespace
 
 #ifndef NDEBUG
 /// Whether a dimension of a set is bounded (lower and upper) by a constant,
 /// 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);
+  auto ParamDims = Set.dim(isl::dim::param).release();
   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   Set = Set.project_out(isl::dim::set, 0, dim);
-  auto SetDims = Set.tuple_dim();
+  auto SetDims = Set.tuple_dim().release();
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 #endif
 
 char MaximalStaticExpander::ID = 0;
 
 isl::union_map MaximalStaticExpander::filterDependences(
for (auto MA : Accesses) {
     MA->setNewAccessRelation(NewAccessMap);
   }
 }
 
 ScopArrayInfo *MaximalStaticExpander::expandAccess(Scop &S, MemoryAccess *MA) {
   // Get the current AM.
   auto CurrentAccessMap = MA->getAccessRelation();
 
-  unsigned in_dimensions = CurrentAccessMap.domain_tuple_dim();
+  unsigned in_dimensions = CurrentAccessMap.domain_tuple_dim().release();
 
   // Get domain from the current AM.
   auto Domain = CurrentAccessMap.domain();
 
   // Create a new AM from the domain.
   auto NewAccessMap = isl::map::from_domain(Domain);
 
   // Add dimensions to the new AM according to the current in_dim.
ScopArrayInfo *MaximalStaticExpander::expandAccess(Scop &S, MemoryAccess *MA) {
   auto NewOutId = ExpandedSAI->getBasePtrId();
 
   // Set the out id of the new AM to the new SAI id.
   NewAccessMap = NewAccessMap.set_tuple_id(isl::dim::out, NewOutId);
 
   // Add constraints to linked output with input id.
   auto SpaceMap = NewAccessMap.get_space();
   auto ConstraintBasicMap =
-      isl::basic_map::equal(SpaceMap, SpaceMap.dim(isl::dim::in));
+      isl::basic_map::equal(SpaceMap, SpaceMap.dim(isl::dim::in).release());
   NewAccessMap = isl::map(ConstraintBasicMap);
 
   // Set the new access relation map.
   MA->setNewAccessRelation(NewAccessMap);
 
   return ExpandedSAI;
 }
 

polly/lib/Transform/ScheduleOptimizer.cpp

ScheduleTreeOptimizer::isolateFullPartialTiles(isl::schedule_node Node,
   isl::union_map SchedRelUMap = Node.get_prefix_schedule_relation();
   isl::union_set ScheduleRangeUSet = SchedRelUMap.range();
   isl::set ScheduleRange{ScheduleRangeUSet};
   isl::set IsolateDomain = getPartialTilePrefixes(ScheduleRange, VectorWidth);
   auto AtomicOption = getDimOptions(IsolateDomain.ctx(), "atomic");
   isl::union_set IsolateOption = getIsolateOptions(IsolateDomain, 1);
   Node = Node.parent().parent();
   isl::union_set Options = IsolateOption.unite(AtomicOption);
-  Node = Node.band_set_ast_build_options(Options);
-  return Node;
+  isl::schedule_node_band Result =
+      Node.as<isl::schedule_node_band>().set_ast_build_options(Options);
+  return Result;
 }
 
 isl::schedule_node ScheduleTreeOptimizer::prevectSchedBand(
     isl::schedule_node Node, unsigned DimToVectorize, int VectorWidth) {
   assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band);
 
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
-  isl_size ScheduleDimensions = Space.dim(isl::dim::set);
+  isl_size ScheduleDimensions = Space.dim(isl::dim::set).release();
   assert((isl_size)DimToVectorize < ScheduleDimensions);
 
   if (DimToVectorize > 0) {
     Node = isl::manage(
         isl_schedule_node_band_split(Node.release(), DimToVectorize));
     Node = Node.child(0);
   }
   if ((isl_size)DimToVectorize < ScheduleDimensions - 1)
     Node = isl::manage(isl_schedule_node_band_split(Node.release(), 1));
   Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
   auto Sizes = isl::multi_val::zero(Space);
   Sizes = Sizes.set_val(0, isl::val(Node.ctx(), VectorWidth));
   Node =
       isl::manage(isl_schedule_node_band_tile(Node.release(), Sizes.release()));
   Node = isolateFullPartialTiles(Node, VectorWidth);
   Node = Node.child(0);
   // Make sure the "trivially vectorizable loop" is not unrolled. Otherwise,
   // we will have troubles to match it in the backend.
-  Node = Node.band_set_ast_build_options(
+  isl::schedule_node_band NodeBand =
+      Node.as<isl::schedule_node_band>().set_ast_build_options(
           isl::union_set(Node.ctx(), "{ unroll[x]: 1 = 0 }"));
-  Node = isl::manage(isl_schedule_node_band_sink(Node.release()));
+  Node = isl::manage(isl_schedule_node_band_sink(NodeBand.release()));
   Node = Node.child(0);
   if (isl_schedule_node_get_type(Node.get()) == isl_schedule_node_leaf)
     Node = Node.parent();
   auto LoopMarker = isl::id::alloc(Node.ctx(), "SIMD", nullptr);
   PrevectOpts++;
   return Node.insert_mark(LoopMarker);
 }
 
bool ScheduleTreeOptimizer::isTileableBandNode(isl::schedule_node Node) {
 
   if (isl_schedule_node_n_children(Node.get()) != 1)
     return false;
 
   if (!isl_schedule_node_band_get_permutable(Node.get()))
     return false;
 
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
-  auto Dims = Space.dim(isl::dim::set);
+  auto Dims = Space.dim(isl::dim::set).release();
 
   if (Dims <= 1)
     return false;
 
   return isSimpleInnermostBand(Node);
 }
 
 __isl_give isl::schedule_node
Node =
         applyRegisterTiling(Node, RegisterTileSizes, RegisterDefaultTileSize);
     RegisterTileOpts++;
   }
 
   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);
+  auto Dims = Space.dim(isl::dim::set).release();
 
   for (int i = Dims - 1; i >= 0; i--)
-    if (Node.band_member_get_coincident(i)) {
+    if (Node.as<isl::schedule_node_band>().member_get_coincident(i)) {
       Node = prevectSchedBand(Node, i, PrevectorWidth);
       break;
     }
 
   return Node;
 }
 
 __isl_give isl_schedule_node *
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.as<isl::schedule_node_band>().member_get_coincident(i))
               NumCoincident[Version]++;
           }
           break;
         }
 
         case isl_schedule_node_filter:
           NumFilters[Version]++;
           break;

polly/lib/Transform/ScheduleTreeTransform.cpp

struct ScheduleTreeRewriter
   }
 
   isl::schedule visitBand(const isl::schedule_node &Band, Args... args) {
     isl::multi_union_pw_aff PartialSched =
         isl::manage(isl_schedule_node_band_get_partial_schedule(Band.get()));
     isl::schedule NewChild =
         getDerived().visit(Band.child(0), std::forward<Args>(args)...);
     isl::schedule_node NewNode =
-        NewChild.insert_partial_schedule(PartialSched).get_root().get_child(0);
+        NewChild.insert_partial_schedule(PartialSched).get_root().child(0);
 
     // Reapply permutability and coincidence attributes.
     NewNode = isl::manage(isl_schedule_node_band_set_permutable(
         NewNode.release(), isl_schedule_node_band_get_permutable(Band.get())));
     unsigned BandDims = isl_schedule_node_band_n_member(Band.get());
     for (unsigned i = 0; i < BandDims; i += 1)
       NewNode = isl::manage(isl_schedule_node_band_member_set_coincident(
           NewNode.release(), i,
isl::schedule visitSet(const isl::schedule_node &Set, Args... args) {
     return Result;
   }
 
   isl::schedule visitLeaf(const isl::schedule_node &Leaf, Args... args) {
     return isl::schedule::from_domain(Leaf.get_domain());
   }
 
   isl::schedule visitMark(const isl::schedule_node &Mark, Args... args) {
-    isl::id TheMark = Mark.mark_get_id();
+
+    isl::id TheMark = Mark.as<isl::schedule_node_mark>().get_id();
     isl::schedule_node NewChild =
         getDerived()
             .visit(Mark.first_child(), std::forward<Args>(args)...)
             .get_root()
             .first_child();
     return NewChild.insert_mark(TheMark).get_schedule();
   }
 
   isl::schedule visitExtension(const isl::schedule_node &Extension,
                                Args... args) {
-    isl::union_map TheExtension = Extension.extension_get_extension();
+    isl::union_map TheExtension =
+        Extension.as<isl::schedule_node_extension>().get_extension();
     isl::schedule_node NewChild = getDerived()
                                       .visit(Extension.child(0), args...)
                                       .get_root()
                                       .first_child();
     isl::schedule_node NewExtension =
         isl::schedule_node::from_extension(TheExtension);
     return NewChild.graft_before(NewExtension).get_schedule();
   }
 
   isl::schedule visitFilter(const isl::schedule_node &Filter, Args... args) {
-    isl::union_set FilterDomain = Filter.filter_get_filter();
+    isl::union_set FilterDomain =
+        Filter.as<isl::schedule_node_filter>().get_filter();
     isl::schedule NewSchedule =
         getDerived().visit(Filter.child(0), std::forward<Args>(args)...);
     return NewSchedule.intersect_domain(FilterDomain);
   }
 
   isl::schedule visitNode(const isl::schedule_node &Node, Args... args) {
     llvm_unreachable("Not implemented");
   }
isl::schedule visitBand(const isl::schedule_node &OldNode,
     isl::union_map NewChildExtensions;
     isl::schedule NewChild = visit(OldChild, Domain, NewChildExtensions);
 
     // Add the extensions to the partial schedule.
     OuterExtensions = isl::union_map::empty(NewChildExtensions.ctx());
     isl::union_map NewPartialSchedMap = isl::union_map::from(PartialSched);
     unsigned BandDims = isl_schedule_node_band_n_member(OldNode.get());
     for (isl::map Ext : NewChildExtensions.get_map_list()) {
-      unsigned ExtDims = Ext.domain_tuple_dim();
+      unsigned ExtDims = Ext.domain_tuple_dim().release();
       assert(ExtDims >= BandDims);
       unsigned OuterDims = ExtDims - BandDims;
 
       isl::map BandSched =
           Ext.project_out(isl::dim::in, 0, OuterDims).reverse();
       NewPartialSchedMap = NewPartialSchedMap.unite(BandSched);
 
       // There might be more outer bands that have to schedule the extensions.
       if (OuterDims > 0) {
         isl::map OuterSched =
             Ext.project_out(isl::dim::in, OuterDims, BandDims);
         OuterExtensions = OuterExtensions.unite(OuterSched);
       }
     }
     isl::multi_union_pw_aff NewPartialSchedAsAsMultiUnionPwAff =
         isl::multi_union_pw_aff::from_union_map(NewPartialSchedMap);
     isl::schedule_node NewNode =
         NewChild.insert_partial_schedule(NewPartialSchedAsAsMultiUnionPwAff)
             .get_root()
-            .get_child(0);
+            .child(0);
 
     // Reapply permutability and coincidence attributes.
     NewNode = isl::manage(isl_schedule_node_band_set_permutable(
         NewNode.release(),
         isl_schedule_node_band_get_permutable(OldNode.get())));
     for (unsigned i = 0; i < BandDims; i += 1) {
       NewNode = isl::manage(isl_schedule_node_band_member_set_coincident(
           NewNode.release(), i,
           isl_schedule_node_band_member_get_coincident(OldNode.get(), i)));
     }
 
     return NewNode.get_schedule();
   }
 
   isl::schedule visitFilter(const isl::schedule_node &Filter,
                             const isl::union_set &Domain,
                             isl::union_map &Extensions) {
-    isl::union_set FilterDomain = Filter.filter_get_filter();
+    isl::union_set FilterDomain =
+        Filter.as<isl::schedule_node_filter>().get_filter();
     isl::union_set NewDomain = Domain.intersect(FilterDomain);
 
     // A filter is added implicitly if necessary when joining schedule trees.
     return visit(Filter.first_child(), NewDomain, Extensions);
   }
 
   isl::schedule visitExtension(const isl::schedule_node &Extension,
                                const isl::union_set &Domain,
                                isl::union_map &Extensions) {
-    isl::union_map ExtDomain = Extension.extension_get_extension();
+    isl::union_map ExtDomain =
+        Extension.as<isl::schedule_node_extension>().get_extension();
     isl::union_set NewDomain = Domain.unite(ExtDomain.range());
     isl::union_map ChildExtensions;
     isl::schedule NewChild =
         visit(Extension.first_child(), NewDomain, ChildExtensions);
     Extensions = ChildExtensions.unite(ExtDomain);
     return NewChild;
   }
 };
isl::schedule visitSchedule(const isl::schedule &Schedule) {
     isl::schedule Result = visit(Schedule).get_schedule();
     assert(Pos == ASTBuildOptions.size() &&
            "AST build options must match to band nodes");
     return Result;
   }
 
   isl::schedule_node visitBand(const isl::schedule_node &Band) {
     isl::schedule_node Result =
-        Band.band_set_ast_build_options(ASTBuildOptions[Pos]);
+        Band.as<isl::schedule_node_band>().set_ast_build_options(
+            ASTBuildOptions[Pos]);
     Pos += 1;
     return getBase().visitBand(Result);
   }
 };
 
 /// Return whether the schedule contains an extension node.
 static bool containsExtensionNode(isl::schedule Schedule) {
   assert(!Schedule.is_null());

 
 /// A loop consists of a band and an optional marker that wraps it. Return the
 /// outermost of the two.
 
 /// That is, either the mark or, if there is not mark, the loop itself. Can
 /// start with either the mark or the band.
 static isl::schedule_node moveToBandMark(isl::schedule_node BandOrMark) {
   if (isBandMark(BandOrMark)) {
-    assert(isBandWithSingleLoop(BandOrMark.get_child(0)));
+    assert(isBandWithSingleLoop(BandOrMark.child(0)));
     return BandOrMark;
   }
   assert(isBandWithSingleLoop(BandOrMark));
 
   isl::schedule_node Mark = BandOrMark.parent();
   if (isBandMark(Mark))
     return Mark;
 
   // Band has no loop marker.
   return BandOrMark;
 }
 
 static isl::schedule_node removeMark(isl::schedule_node MarkOrBand,
                                      BandAttr *&Attr) {
   MarkOrBand = moveToBandMark(MarkOrBand);
 
   isl::schedule_node Band;
   if (isMark(MarkOrBand)) {
-    Attr = getLoopAttr(MarkOrBand.mark_get_id());
+    Attr = getLoopAttr(MarkOrBand.as<isl::schedule_node_mark>().get_id());
     Band = isl::manage(isl_schedule_node_delete(MarkOrBand.release()));
   } else {
     Attr = nullptr;
     Band = MarkOrBand;
   }
 
   assert(isBandWithSingleLoop(Band));
   return Band;
 }
 
 /// Remove the mark that wraps a loop. Return the band representing the loop.
 static isl::schedule_node removeMark(isl::schedule_node MarkOrBand) {
   BandAttr *Attr;
   return removeMark(MarkOrBand, Attr);
 }
 
 static isl::schedule_node insertMark(isl::schedule_node Band, isl::id Mark) {
   assert(isBand(Band));
   assert(moveToBandMark(Band).is_equal(Band) &&
          "Don't add a two marks for a band");
 
-  return Band.insert_mark(Mark).get_child(0);
+  return Band.insert_mark(Mark).child(0);
 }
 
 /// Return the (one-dimensional) set of numbers that are divisible by @p Factor
 /// with remainder @p Offset.
 ///
 ///  isDivisibleBySet(Ctx, 4, 0) = { [i] : floord(i,4) = 0 }
 ///  isDivisibleBySet(Ctx, 4, 1) = { [i] : floord(i,4) = 1 }
 ///
static isl::basic_set isDivisibleBySet(isl::ctx &Ctx, long Factor,
   return Modulo.domain();
 }
 
 /// Make the last dimension of Set to take values from 0 to VectorWidth - 1.
 ///
 /// @param Set         A set, which should be modified.
 /// @param VectorWidth A parameter, which determines the constraint.
 static isl::set addExtentConstraints(isl::set Set, int VectorWidth) {
-  unsigned Dims = Set.tuple_dim();
+  unsigned Dims = Set.tuple_dim().release();
   isl::space Space = Set.get_space();
   isl::local_space LocalSpace = isl::local_space(Space);
   isl::constraint ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(0);
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, 1);
   Set = Set.add_constraint(ExtConstr);
   ExtConstr = isl::constraint::alloc_inequality(LocalSpace);
   ExtConstr = ExtConstr.set_constant_si(VectorWidth - 1);
   ExtConstr = ExtConstr.set_coefficient_si(isl::dim::set, Dims - 1, -1);
   return Set.add_constraint(ExtConstr);
 }
 } // namespace
 
 bool polly::isBandMark(const isl::schedule_node &Node) {
-  return isMark(Node) && isLoopAttr(Node.mark_get_id());
+  return isMark(Node) &&
+         isLoopAttr(Node.as<isl::schedule_node_mark>().get_id());
 }
 
 BandAttr *polly::getBandAttr(isl::schedule_node MarkOrBand) {
   MarkOrBand = moveToBandMark(MarkOrBand);
   if (!isMark(MarkOrBand))
     return nullptr;
 
-  return getLoopAttr(MarkOrBand.mark_get_id());
+  return getLoopAttr(MarkOrBand.as<isl::schedule_node_mark>().get_id());
 }
 
 isl::schedule polly::hoistExtensionNodes(isl::schedule Sched) {
   // If there is no extension node in the first place, return the original
   // schedule tree.
   if (!containsExtensionNode(Sched))
     return Sched;
 
isl::schedule polly::applyFullUnroll(isl::schedule_node BandToUnroll) {
   isl::ctx Ctx = BandToUnroll.ctx();
 
   // Remove the loop's mark, the loop will disappear anyway.
   BandToUnroll = removeMark(BandToUnroll);
   assert(isBandWithSingleLoop(BandToUnroll));
 
   isl::multi_union_pw_aff PartialSched = isl::manage(
       isl_schedule_node_band_get_partial_schedule(BandToUnroll.get()));
-  assert(PartialSched.dim(isl::dim::out) == 1 &&
+  assert(PartialSched.dim(isl::dim::out).release() == 1 &&
          "Can only unroll a single dimension");
-  isl::union_pw_aff PartialSchedUAff = PartialSched.get_union_pw_aff(0);
+  isl::union_pw_aff PartialSchedUAff = PartialSched.at(0);
 
   isl::union_set Domain = BandToUnroll.get_domain();
   PartialSchedUAff = PartialSchedUAff.intersect_domain(Domain);
-  isl::union_map PartialSchedUMap = isl::union_map(PartialSchedUAff);
+  isl::union_map PartialSchedUMap =
+      isl::union_map::from(isl::union_pw_multi_aff(PartialSchedUAff));
 
   // Enumerator only the scatter elements.
   isl::union_set ScatterList = PartialSchedUMap.range();
 
   // Enumerate all loop iterations.
   // TODO: Diagnose if not enumerable or depends on a parameter.
   SmallVector<isl::point, 16> Elts;
   ScatterList.foreach_point([&Elts](isl::point P) -> isl::stat {
     Elts.push_back(P);
     return isl::stat::ok();
   });
 
   // Don't assume that foreach_point returns in execution order.
   llvm::sort(Elts, [](isl::point P1, isl::point P2) -> bool {
     isl::val C1 = P1.get_coordinate_val(isl::dim::set, 0);
     isl::val C2 = P2.get_coordinate_val(isl::dim::set, 0);
     return C1.lt(C2);
   });
 
   // Convert the points to a sequence of filters.
-  isl::union_set_list List = isl::union_set_list::alloc(Ctx, Elts.size());
+  isl::union_set_list List = isl::union_set_list(Ctx, Elts.size());
   for (isl::point P : Elts) {
     // Determine the domains that map this scatter element.
     isl::union_set DomainFilter = PartialSchedUMap.intersect_range(P).domain();
 
     List = List.add(DomainFilter);
   }
 
   // Replace original band with unrolled sequence.
isl::schedule polly::applyPartialUnroll(isl::schedule_node BandToUnroll,
   BandAttr *Attr;
   BandToUnroll = removeMark(BandToUnroll, Attr);
   assert(isBandWithSingleLoop(BandToUnroll));
 
   isl::multi_union_pw_aff PartialSched = isl::manage(
       isl_schedule_node_band_get_partial_schedule(BandToUnroll.get()));
 
   // { Stmt[] -> [x] }
-  isl::union_pw_aff PartialSchedUAff = PartialSched.get_union_pw_aff(0);
+  isl::union_pw_aff PartialSchedUAff = PartialSched.at(0);
 
   // Here we assume the schedule stride is one and starts with 0, which is not
   // necessarily the case.
   isl::union_pw_aff StridedPartialSchedUAff =
       isl::union_pw_aff::empty(PartialSchedUAff.get_space());
   isl::val ValFactor{Ctx, Factor};
   PartialSchedUAff.foreach_pw_aff([&StridedPartialSchedUAff,
                                    &ValFactor](isl::pw_aff PwAff) -> isl::stat {
     isl::space Space = PwAff.get_space();
     isl::set Universe = isl::set::universe(Space.domain());
     isl::pw_aff AffFactor{Universe, ValFactor};
     isl::pw_aff DivSchedAff = PwAff.div(AffFactor).floor().mul(AffFactor);
     StridedPartialSchedUAff = StridedPartialSchedUAff.union_add(DivSchedAff);
     return isl::stat::ok();
   });
 
-  isl::union_set_list List = isl::union_set_list::alloc(Ctx, Factor);
+  isl::union_set_list List = isl::union_set_list(Ctx, Factor);
   for (auto i : seq<int>(0, Factor)) {
     // { Stmt[] -> [x] }
-    isl::union_map UMap{PartialSchedUAff};
+    isl::union_map UMap =
+        isl::union_map::from(isl::union_pw_multi_aff(PartialSchedUAff));
 
     // { [x] }
     isl::basic_set Divisible = isDivisibleBySet(Ctx, Factor, i);
 
     // { Stmt[] }
     isl::union_set UnrolledDomain = UMap.intersect_range(Divisible).domain();
 
     List = List.add(UnrolledDomain);
isl::schedule polly::applyPartialUnroll(isl::schedule_node BandToUnroll,
   if (!NewBandId.is_null())
     NewLoop = insertMark(NewLoop, NewBandId);
 
   return NewLoop.get_schedule();
 }
 
 isl::set polly::getPartialTilePrefixes(isl::set ScheduleRange,
                                        int VectorWidth) {
-  isl_size Dims = ScheduleRange.tuple_dim();
+  isl_size Dims = ScheduleRange.tuple_dim().release();
   isl::set LoopPrefixes =
       ScheduleRange.drop_constraints_involving_dims(isl::dim::set, Dims - 1, 1);
   auto ExtentPrefixes = addExtentConstraints(LoopPrefixes, VectorWidth);
   isl::set BadPrefixes = ExtentPrefixes.subtract(ScheduleRange);
   BadPrefixes = BadPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   LoopPrefixes = LoopPrefixes.project_out(isl::dim::set, Dims - 1, 1);
   return LoopPrefixes.subtract(BadPrefixes);
 }
 
 isl::union_set polly::getIsolateOptions(isl::set IsolateDomain,
                                         isl_size OutDimsNum) {
-  isl_size Dims = IsolateDomain.tuple_dim();
+  isl_size Dims = IsolateDomain.tuple_dim().release();
   assert(OutDimsNum <= Dims &&
          "The isl::set IsolateDomain is used to describe the range of schedule "
          "dimensions values, which should be isolated. Consequently, the "
          "number of its dimensions should be greater than or equal to the "
          "number of the schedule dimensions.");
   isl::map IsolateRelation = isl::map::from_domain(IsolateDomain);
   IsolateRelation = IsolateRelation.move_dims(isl::dim::out, 0, isl::dim::in,
                                               Dims - OutDimsNum, OutDimsNum);

 isl::schedule_node polly::tileNode(isl::schedule_node Node,
                                    const char *Identifier,
                                    ArrayRef<int> TileSizes,
                                    int DefaultTileSize) {
   auto Space = isl::manage(isl_schedule_node_band_get_space(Node.get()));
   auto Dims = Space.dim(isl::dim::set);
   auto Sizes = isl::multi_val::zero(Space);
   std::string IdentifierString(Identifier);
-  for (auto i : seq<isl_size>(0, Dims)) {
+  for (auto i : seq<isl_size>(0, Dims.release())) {
     auto tileSize =
         i < (isl_size)TileSizes.size() ? TileSizes[i] : DefaultTileSize;
     Sizes = Sizes.set_val(i, isl::val(Node.ctx(), tileSize));
   }
   auto TileLoopMarkerStr = IdentifierString + " - Tiles";
   auto TileLoopMarker = isl::id::alloc(Node.ctx(), TileLoopMarkerStr, nullptr);
   Node = Node.insert_mark(TileLoopMarker);
   Node = Node.child(0);
   Node =
       isl::manage(isl_schedule_node_band_tile(Node.release(), Sizes.release()));
   Node = Node.child(0);
   auto PointLoopMarkerStr = IdentifierString + " - Points";
   auto PointLoopMarker =
       isl::id::alloc(Node.ctx(), PointLoopMarkerStr, nullptr);
   Node = Node.insert_mark(PointLoopMarker);
   return Node.child(0);
 }
 
 isl::schedule_node polly::applyRegisterTiling(isl::schedule_node Node,
                                               ArrayRef<int> TileSizes,
                                               int DefaultTileSize) {
   Node = tileNode(Node, "Register tiling", TileSizes, DefaultTileSize);
   auto Ctx = Node.ctx();
-  return Node.band_set_ast_build_options(isl::union_set(Ctx, "{unroll[x]}"));
+  return Node.as<isl::schedule_node_band>().set_ast_build_options(
+      isl::union_set(Ctx, "{unroll[x]}"));
 }

polly/lib/Transform/Simplify.cpp

static isl::union_map underapproximatedAddMap(isl::union_map UMap,
   // Fast path: If known that we cannot exceed the disjunct limit, just add
   // them.
   if (isl_map_n_basic_map(PrevMap.get()) + isl_map_n_basic_map(Map.get()) <=
       SimplifyMaxDisjuncts)
     return UMap.unite(Map);
 
   isl::map Result = isl::map::empty(PrevMap.get_space());
   for (isl::basic_map BMap : PrevMap.get_basic_map_list()) {
-    if (Result.n_basic_map() > SimplifyMaxDisjuncts)
+    if (Result.n_basic_map().release() > SimplifyMaxDisjuncts)
       break;
     Result = Result.unite(BMap);
   }
   for (isl::basic_map BMap : Map.get_basic_map_list()) {
     if (isl_map_n_basic_map(Result.get()) > SimplifyMaxDisjuncts)
       break;
     Result = Result.unite(BMap);
   }

polly/lib/Transform/ZoneAlgo.cpp

 }
 
 /// 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;
+         Space.is_wrapping().is_false() &&
+         Space.dim(isl::dim::set).release() == 0;
 }
 
 isl::union_map polly::filterKnownValInst(const isl::union_map &UMap) {
   isl::union_map Result = isl::union_map::empty(UMap.ctx());
   for (isl::map Map : UMap.get_map_list()) {
     if (!isMapToUnknown(Map))
       Result = Result.unite(Map);
   }
isl::map ZoneAlgorithm::getDefToTarget(ScopStmt *DefStmt,
   //   { DefStmt[i] -> TargetStmt[i,j] }
   //
   // In practice, this should cover the majority of cases.
   if (Result.is_null() && S->isOriginalSchedule() &&
       isInsideLoop(DefStmt->getSurroundingLoop(),
                    TargetStmt->getSurroundingLoop())) {
     isl::set DefDomain = getDomainFor(DefStmt);
     isl::set TargetDomain = getDomainFor(TargetStmt);
-    assert(DefDomain.tuple_dim() <= TargetDomain.tuple_dim());
+    assert(DefDomain.tuple_dim().release() <=
+           TargetDomain.tuple_dim().release());
 
     Result = isl::map::from_domain_and_range(DefDomain, TargetDomain);
-    for (unsigned i = 0, DefDims = DefDomain.tuple_dim(); i < DefDims; i += 1)
+    for (unsigned i = 0, DefDims = DefDomain.tuple_dim().release(); i < DefDims;
+         i += 1)
       Result = Result.equate(isl::dim::in, i, isl::dim::out, i);
   }
 
   if (Result.is_null()) {
     // { DomainDef[] -> DomainTarget[] }
     Result = computeUseToDefFlowDependency(TargetStmt, DefStmt).reverse();
     simplify(Result);
   }

polly/unittests/Isl/IslTest.cpp

EXPECT_EQ(MAP("[i] -> { [i] -> [i] }"),
             singleton(UMAP("[i] -> { [i] -> [i] }"), SPACE("{ [i] -> [j] }")));
 }
 
 TEST(ISLTools, getNumScatterDims) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
   // Basic usage
-  EXPECT_EQ(0, getNumScatterDims(UMAP("{ [] -> [] }")));
-  EXPECT_EQ(1, getNumScatterDims(UMAP("{ [] -> [i] }")));
-  EXPECT_EQ(2, getNumScatterDims(UMAP("{ [] -> [i,j] }")));
-  EXPECT_EQ(3, getNumScatterDims(UMAP("{ [] -> [i,j,k] }")));
+  EXPECT_EQ(0u, getNumScatterDims(UMAP("{ [] -> [] }")));
+  EXPECT_EQ(1u, getNumScatterDims(UMAP("{ [] -> [i] }")));
+  EXPECT_EQ(2u, getNumScatterDims(UMAP("{ [] -> [i,j] }")));
+  EXPECT_EQ(3u, getNumScatterDims(UMAP("{ [] -> [i,j,k] }")));
 
   // Different scatter spaces
-  EXPECT_EQ(0, getNumScatterDims(UMAP("{ A[] -> []; [] -> []}")));
-  EXPECT_EQ(1, getNumScatterDims(UMAP("{ A[] -> []; [] -> [i] }")));
-  EXPECT_EQ(2, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
-  EXPECT_EQ(3, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
+  EXPECT_EQ(0u, getNumScatterDims(UMAP("{ A[] -> []; [] -> []}")));
+  EXPECT_EQ(1u, getNumScatterDims(UMAP("{ A[] -> []; [] -> [i] }")));
+  EXPECT_EQ(2u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j] }")));
+  EXPECT_EQ(3u, getNumScatterDims(UMAP("{ A[] -> [i]; [] -> [i,j,k] }")));
 }
 
 TEST(ISLTools, getScatterSpace) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
   // Basic usage
   EXPECT_EQ(SPACE("{ [] }"), getScatterSpace(UMAP("{ [] -> [] }")));

polly/unittests/Support/ISLTools.cpp

TEST(Support, isl_iterator) {
   isl::ctx Ctx(RawCtx.get());
 
   isl::basic_set A(
       Ctx, "{ [x, y] : 0 <= x <= 5 and y >= 0 and x > 0 and 0 < y <= 5 }");
   isl::basic_set B(
       Ctx, "{ [x, y] : 0 <= x <= 5 and y >= 0 and x <= 4 and y <= 3 + x }");
   isl::set S = A.unite(B);
 
-  ASSERT_EQ(S.n_basic_set(), 2);
+  ASSERT_EQ(S.n_basic_set().release(), 2);
   std::vector<isl::basic_set> Sets;
   for (auto BS : S.get_basic_set_list())
     Sets.push_back(BS);
   EXPECT_THAT(Sets, testing::UnorderedElementsAre(A, B));
 }